最近集训的图论（思路+实现）题目汇总（内容包含tarjan、分层图、拓扑、差分、奇怪的最短路）：
（集训模拟赛2）抢掠计划（tarjan强）
题目：给你n个点，m条边的图，每个点有点权，有一些点是“酒吧”点，终点只能在“酒吧”，起点给定，路可以重复经过，但点权只能加一次，求最大的结果。
例如这个图，双实线表示是酒吧，结果呢是1->2->4->1->2->3->5所得值。
输入格式：
第一行N,M，下面M行是边，下面N行是点权，下面1行是起点与酒吧数量，下面一行是“酒吧”点的编号。
思路：
注意到：（边可以重复走，而点权只算一遍）这个条件，说明只要走到了一个环中的一个点，这个环里面所有点就一定都能走到，因为你可以走一圈回到入环的起点。
这是什么呢？这是名为“缩点”的高级技巧在呼唤！
我们可以把所有环看作一个点，权值是环内所有点权之和，只要环中有一个点是“酒吧”，那这个大环就可以看作一个“酒吧”，然后从起点所在“大点”开始，跑一遍单源最短路，找最大的路径长度即可（spfa最长路，dfs硬搜会被卡（搜，就硬搜））
代码：
#include<queue>
#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=5e5+10;
struct E{int from,to,next;}edge[maxn];
E edge2[maxn];int head2[maxn],tot2;
int head[maxn],tot;
void add(int from,int to){
edge[++tot].from=from;
edge[tot].to=to;
edge[tot].next=head[from];
head[from]=tot;
}
void add2(int from,int to){
edge2[++tot2].to=to;
edge2[tot2].next=head2[from];
head2[from]=tot2;
}
int dfn[maxn],vis[maxn],low[maxn];
int sta[maxn],top,Time;
int belong[maxn],belongcnt,size[maxn];
int val[maxn],drink[maxn],drink2[maxn];
void tarjan(int u){
if(dfn[u])return;
low[u]=dfn[u]=++Time;
vis[u]=1;sta[++top]=u;
for(int i=head[u];i;i=edge[i].next){
int v=edge[i].to;
if(!dfn[v]){
tarjan(v);
low[u]=min(low[u],low[v]);
}else if(vis[v]){
low[u]=min(low[u],dfn[v]);
}
}
if(low[u]==dfn[u]){
belongcnt++;
while(sta[top+1]!=u){
belong[sta[top]]=belongcnt;
size[belongcnt]+=val[sta[top]];
vis[sta[top]]=0;
if(drink[sta[top]])drink2[belong[sta[top]]]=true;
top--;
}
}
}
int viss[maxn],diss[maxn];
void spfa(int s){
queue<int> q;
viss[s]=1;diss[s]=size[s];
q.push(s);
while(!q.empty()){
int u=q.front();q.pop();viss[u]=0;
for(int i=head2[u];i;i=edge2[i].next){
int v=edge2[i].to;
if(diss[v]<diss[u]+size[v]){
diss[v]=diss[u]+size[v];
if(!viss[v]){
viss[v]=1;
q.push(v);
}
}
}
}
}
int main(){
int m,n;
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++){
int from,to;
scanf("%d%d",&from,&to);
add(from,to);
}
for(int i=1;i<=n;i++){
scanf("%d",&val[i]);
}
int begin,dnum;
scanf("%d%d",&begin,&dnum);
for(int i=1;i<=dnum;i++){
int x;
scanf("%d",&x);
drink[x]=true;
}
for(int i=1;i<=n;i++){
tarjan(i);
}
for(int i=1;i<=m;i++){
if(belong[edge[i].from]!=belong[edge[i].to]){
add2(belong[edge[i].from],belong[edge[i].to]);
}
}
//缩完后点之间的边
spfa(belong[begin]);
int ans=0;
for(int i=1;i<=belongcnt;i++){
if(drink2[i])ans=max(ans,diss[i]);//只有是酒吧才算最大值
}
printf("%d",ans);
return 0;
}
（集训模拟赛3）清理牛棚（思维最短路）
题目：
简而言之，就是给你i个牛，每个牛可以清扫M到E，代价为S，问覆盖全部区间的最小代价（这不显然是线段树板子吗）
分析：
我们可以这么想，如果一头牛从i打扫到j，那么就从i到j+1建一条边（题目中说了牛打扫的是闭区间，所以我们建边时候要处理一下，把[i，j]变成[i，j+1)否则加边区间会重复）
然后呢，我们对于每一个i点，都建一条权值为0的i到i-1的边，然后从起点到终点跑最短路。
这是为什么呢？
我们想一想，如果有两头牛，他们分别打扫1->5,2->6,如果不建反向的权值为0的边，那么这个情况下1和6是不联通的，我们需要解决这种有重叠区间的问题的话，只要从5到2建一条权值为0的边，这样在跑最短路跑到5的时候，可以回到2继续跑。所以，我们的方案就是通过反向建0的边，使本来不联通的“重叠”区间也可以连起来，而且这样不会影响最后结果，之前不联通，这样操作还是不联通，因为反向建的边是单向的，只能从较后位置到较前位置。
代码：
#include<bits/stdc++.h>
using namespace std;
const int maxn=1e6+10;
struct E{
int to,val,next;
}edge[maxn];
int head[maxn],tot;
void add(int from,int to,int val){
edge[++tot].to=to;
edge[tot].val=val;
edge[tot].next=head[from];
head[from]=tot;
}
int n,m,e;
int vis[maxn],d[maxn];
void spfa(int s){
memset(d,0x3f,sizeof(d));
queue<int> q;
d[s]=0;vis[s]=1;q.push(s);
while(!q.empty()){
int u=q.front();
q.pop();
vis[u]=0;
for(int i=head[u];i;i=edge[i].next){
int v=edge[i].to;
if(vis[v])continue;
if(d[v]>d[u]+edge[i].val){
d[v]=d[u]+edge[i].val;
q.push(v);
vis[v]=1;
}
}
}
}
int main(){
scanf("%d%d%d",&n,&m,&e);
for(int i=m;i<=e;i++){
add(i+1,i,0);
}
for(int i=1;i<=n;i++){
int from,to,val;
scanf("%d%d%d",&from,&to,&val);
to++;
add(from,to,val);
}
spfa(m);
if(d[e+1]==0x3f3f3f3f){
printf("-1");
return 0;
}
printf("%d",d[e+1]);//注意最后的区间变成了[m,e+1)而不是[m,e]了
return 0;
}
（集训模拟赛4）浇水（思维最短路）
题目：
其实这道题是个贪心
分析：
我们可以这样考虑：每一个喷射装置覆盖一个圆形的面积，但是如果喷射半径小于m/2，那这个喷头相当于废了，它连自己的上下都喷不到，就不可能选它了，接着，面积什么的显然不好处理，还会有一些重叠就更不好了，我们可以把每个喷头所覆盖的n上面长度作为该喷头的“有效范围”，由于上下对称性，只要长方形的一条长被覆盖满了，另外一条必覆盖满，所以我们把这道题看作有n个喷头，每个喷头覆盖l到r，求覆盖所有区间的最小数量。
emm，这句话怎么这么熟悉？看了一下上一道题的描述（显然这两道题是一道题）
所以打出代码来，也跟上一道题是一样的，我就不放代码了
显然还是有一些区别的，比如这道题每一个喷头覆盖区间的左右端点是doube类型，不能直接当结点，会有蛋疼的精度问题，所以……
我们直接把每一个double值扩大一个倍数转成整形，相应的n也扩大，这样就可以代入上一道题的代码了。（×5就可以）
附上代码：
#include<bits/stdc++.h>
using namespace std;
const int maxn=1e7+10;
int k,n,m;
struct E{
int to,val,next;
}edge[maxn];
int head[maxn],tot;
void add(int from,int to,int val){
edge[++tot].to=to;
edge[tot].val=val;
edge[tot].next=head[from];
head[from]=tot;
}
int vis[maxn],d[maxn];
void spfa(int s){
memset(d,0x3f,sizeof(d));
queue<int> q;
d[s]=0;vis[s]=1;q.push(s);
while(!q.empty()){
int u=q.front();
//printf("%d ",u);
q.pop();
vis[u]=0;
for(int i=head[u];i;i=edge[i].next){
int v=edge[i].to;
if(vis[v])continue;
if(d[v]>d[u]+edge[i].val){
d[v]=d[u]+edge[i].val;
q.push(v);
vis[v]=1;
}
}
}
}
int main(){
scanf("%d%d%d",&k,&n,&m);
for(int i=1;i<=k;i++){
int aa,r;
scanf("%d%d",&aa,&r);
if(r<=m/2)continue;
int ll=(int)(aa*5-sqrt(r*r-m*m/4)*5);
int rr=(int)(aa*5+sqrt(r*r-m*m/4)*5);
//区间变为：[当前位置×5-向左的距离×5,当前位置×5+向右的距离×5+1);
//因为该区间相当于这个喷头覆盖范围的一个弦，所以左右延伸的距离（半弦长）=根号（半径平方-弦心距平方)/2;
if(ll<0)ll=0;
add(ll,rr+1,1);
}
for(int i=1;i<=n*25;i++)add(i,i-1,0);
spfa(0);
if(d[n*5+1]==0x3f3f3f3f)d[n*5+1]=-1;
printf("%d",d[n*5+1]);
return 0;
}
（集训模拟赛8）升降梯上（思维最短路）
（集训模拟赛8）升降梯上（分层图最短路）
题目大意：
有n层楼，你现在在第1层，有一个电梯，上面有个拉杆，有m个控制槽，槽上有数字，拨到哪个槽就上升相应层数（不能下降到<=0或上升到>n层），最开始拉杆在“0”槽位处，数字有正有负，且控制槽之间的数字是有顺序的，每移动一格控制槽需要1s，每上或下一层楼要2s，问走到顶楼的最小时间。
分析：（看起来是个dp，好像也可以推出来转移方程，但是会有一些小问题，这边只考虑正解（最短路）。）
我们把每种需要花费时间的操作当成边来处理，时间就是边的权值。
我们可以把每一层的每一个控制槽看作一个结点，它向本层的其它槽位的点建边（因为这需要话费时间），还向它指向的那一层的这个槽建一条边（同上），权值按照题目要求设定。（注意：二维的点（i，j）不适合作为图的结点，我们可以把每一个点的坐标处理一下，变成一维的点，然后剩下的操作就好处理了。）
主要步骤：
1.转点，第一层的点从1到m，第二层的点是m+1到2*m……第n层的点是（n-1）*m+1到n*m。
2.建边，每一个点向周围的槽位和自己指向的槽位建边。
3.最短路，需要从第一层的“0”槽到顶层的槽位中找最小值。
附上代码：
#include<bits/stdc++.h>
using namespace std;
const int maxn=1e6+10;
struct E{
int from;
int to,val,next;
}edge[maxn];
int head[maxn],tot,dis[maxn],vis[maxn];
void add(int from,int to,int val){
edge[++tot].to=to;
edge[tot].from=from;
edge[tot].val=val;
edge[tot].next=head[from];
head[from]=tot;
}
void spfa(int s){
memset(dis,0x3f,sizeof(dis));memset(vis,0,sizeof(vis));
dis[s]=0;vis[s]=1;
queue<int> q;
q.push(s);
while(!q.empty()){
int u=q.front();q.pop();vis[u]=0;
for(int i=head[u];i;i=edge[i].next){
int v=edge[i].to;
if(dis[v]>dis[u]+edge[i].val){
dis[v]=dis[u]+edge[i].val;
if(!vis[v]){
q.push(v);vis[v]=1;
}
}
}
}
}
int n,m,c[maxn];
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++)scanf("%d",&c[i]);//每一个槽位及上面的数字
//建同一层之间的边
for(int now=1;now<=n;now++){
for(int i=1;i<=m;i++){
for(int d=0;d<=m-1;d++){
if(i+d<=m)add((now-1)*m+i,(now-1)*m+i+d,d);
if(i-d>=1)add((now-1)*m+i,(now-1)*m+i-d,d);
}
}
}
//建层与层之间的边
for(int now=1;now<=n;now++){
for(int i=1;i<=m;i++){
if((now-1+c[i])*m+i<=n*m&&(now-1+c[i])*m+i>=1){//边界条件：不超过最大节点（n*m）不小于最小节点（1）
if(c[i]==0)continue;
add((now-1)*m+i,(now-1+c[i])*m+i,2*abs(c[i]));
}
}
}
int start=0;
for(int i=1;i<=m;i++){
if(c[i]==0)start=i;
}
spfa(start);
int Min=0x7fffffff;
for(int i=1;i<=m;i++){
Min=min(Min,dis[(n-1)*m+i]);
}
if(Min==0x3f3f3f3f)Min=-1;
printf("%d",Min);
return 0;
}
（集训模拟赛9）最小环（思维最短路）
题目：
思路：
这道题要求求已知起点的一条最小环，边是无向的但每条边又只能走一次（一看到最小环不就应该知道是最短路了吗）
一般求最小环都是用floyd算法，详情请见老姚博客：https://www.cnblogs.com/hbhszxyb/p/12770720.html
这道题显然n3的效率会炸，所以我们需要另寻它法。
我们知道，一个简单环，断掉一条边就会形成一条链，我们可以利用这一点，尝试断掉某个点与起点相连的一条边，再求起点到它的最短路，那么到这个点的最短路+断掉的这条边权就是起点与这个点所在的环的大小了，我们枚举每一条与起点相连的边，并尝试断掉它，然后求环的大小，取最小值即可。
注意：每次断边要断两个，建议在建边时候按^1的方法去建（0、1是一对反向边，2、3是一对反向边，4、5是一对……），这样在断边时候好处理
附上代码：
#include<bits/stdc++.h>
using namespace std;
const int maxn=4e5+10;
struct E{int to,next,val;}edge[maxn];
int head[maxn],tot,Min=0x3f3f3f3f;
void add(int from,int to,int val){
edge[tot].to=to;
edge[tot].val=val;
edge[tot].next=head[from];
head[from]=tot++;
}
int d[maxn],vis[maxn];
void spfa(int s){
memset(d,0x3f,sizeof(d));
memset(vis,0,sizeof(vis));
queue<int> q;
d[s]=0;
q.push(s);
while(!q.empty()){
int u=q.front();q.pop();vis[u]=0;
for(int i=head[u];~i;i=edge[i].next){
int v=edge[i].to;
if(d[v]>d[u]+edge[i].val){
d[v]=d[u]+edge[i].val;
if(!vis[v]){
q.push(v);
vis[v]=1;
}
}
}
}
}
int n,m,t,from,to,val;
int main(){
scanf("%d",&t);
while(t--){
memset(head,-1,sizeof(head));tot=0;
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++){
scanf("%d%d%d",&from,&to,&val);
add(from,to,val);
add(to,from,val);
}
Min=0x3f3f3f3f;
for(int i=head[1];~i;i=edge[i].next){
int now=edge[i].val;//断掉这条边的边权
int v=edge[i].to;//某个与起点直接相连的点
edge[i].val=edge[i^1].val=0x3f3f3f3f;//断边（给它恢复初始值）
spfa(1);
Min=min(Min,d[v]+now);
edge[i].val=edge[i^1].val=now;//再建回来
}
if(Min==0x3f3f3f3f)Min=-1;
printf("%d\n",Min);
} return 0;
}
（集训模拟赛10）虫洞（分层图最短路）
题目描述
N个虫洞，M条单向跃迁路径。从一个虫洞沿跃迁路径到另一个虫洞需要消耗一定量的燃料和1单位时间。虫洞有白洞和黑洞之分。设一条跃迁路径两端的虫洞质量差为delta。
从白洞跃迁到黑洞，消耗的燃料值减少delta，若该条路径消耗的燃料值变为负数的话，取为0。
从黑洞跃迁到白洞，消耗的燃料值增加delta。
路径两端均为黑洞或白洞，消耗的燃料值不变化。
作为压轴题，自然不会是如此简单的最短路问题，所以每过1单位时间黑洞变为白洞，白洞变为黑洞。在飞行过程中，可以选择在一个虫洞停留1个单位时间，如果当前为白洞，则不消耗燃料，否则消耗s[i] 的燃料。现在请你求出从虫洞1到N最少的燃料消耗，保证一定存在1到N的路线。
输入格式
第1行：2个正整数N, M
第2行：N个整数，第i个为0表示虫洞i开始时为白洞，1 表示黑洞。
第3行：N个整数，第i个数表示虫洞i的质量w[i]。
第4行：N个整数，第i个数表示在虫洞i停留消耗的燃料s[i]。
第5..M+4行：每行3个整数，u,v,k，表示在没有影响的情况下，从虫洞u到虫洞v需要消耗燃料k。
思路：
这道题乍一看是一个最短路，但是它有一些特殊限制，我们就考虑分层图。
何谓分层图？
就是在同一个图里面不太好找出所有情况时，开几个一样的图，在图之间进行那些“特殊操作”（例如边权改为0，边权减半，反向走……），这样不打破原来图的结构，还能更方便快捷的求出结果。
这道题，我们就可以把双数时间点的图和单数时间点的图分开来，建成两个图，因为单数时间和双数时间的黑、白洞情况不同，其他的差别也只在这两个图之间发生。
这道题有几个难处理的地方：
1、一个洞跳到另一个洞后，所有洞的颜色都会改变，我们可以通过再两个图之间建边这个问题，例如样例：
1 2 3 4（洞编号）（黑洞为1，白洞为0）
1 0 1 0（偶数时间状态）
0 1 0 1（奇数时间状态）
我们假如要在3->4这一方向建边，我们就可以让上面图的3号指向下面图的4号，下面图的3号指向上面图的4号，因为从3号到4号转移过后，4号的状态会改变，我们要以4号的新状态再进行之后的操作，所以直接从3号建一条边到改变后的4号，接下来就从改变后的4号再向后进行操作即可。
2.同一个洞可以选择停留，还会消耗1个时间，我们可以在两个图相对应的两个点之间建边解决这个问题。如上图中的1号与下图中的1号，他们之间就满足状态改变，位置不变。
主要思路就是这些，下面附上代码
#include<bits/stdc++.h>
using namespace std;
const int maxn=100010;
int n,m,w[maxn],now[maxn],s;
struct E{int to,next,val;}edge[maxn*6];
int head[maxn],tot;
void add(int from,int to,int val){
edge[++tot].to=to;
edge[tot].val=val;
edge[tot].next=head[from];
head[from]=tot;
}
int dis[maxn],vis[maxn];
void spfa(int s){
memset(dis,0x3f,sizeof(dis));
queue<int> q;
dis[s]=0;q.push(s);
while(!q.empty()){
int u=q.front();q.pop();vis[u]=0;
for(int i=head[u];i;i=edge[i].next){
int v=edge[i].to;
if(dis[v]>dis[u]+edge[i].val){
dis[v]=dis[u]+edge[i].val;
if(!vis[v]){
q.push(v);
vis[v]=1;
}
}
}
}
}
void init(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++){
scanf("%d",&now[i]);
}
for(int i=1;i<=n;i++){
scanf("%d",&w[i]);
}
for(int i=1;i<=n;i++){
scanf("%d",&s);
if(now[i]){//如果是黑洞，那么由黑到白要花费s[i]。（这里now[i]表示偶数时间内的状态）
add(i,i+n,s);
add(i+n,i,0);
}else{//如果是白洞，那么由白到黑花费为0。(这两种情况都要建双向边，当边反过来，黑到白也变成了白到黑)
add(i,i+n,0);
add(i+n,i,s);
}
}
for(int i=1;i<=m;i++){
int from,to,val;
scanf("%d%d%d",&from,&to,&val);
if(now[from]==now[to]){
add(from,to+n,val);
add(from+n,to,val);
//两洞无论什么时候状态都一样，就不用考虑题目中delta的问题
}else{
if(now[from]==1&&now[to]==0){
add(from,to+n,val+abs(w[from]-w[to]));
int x=max(0,val-abs(w[from]-w[to]));
add(from+n,to,x);
//前黑后白
}else if(now[from]==0&&now[to]==1){
add(from+n,to,val+abs(w[from]-w[to]));
int x=max(0,val-abs(w[from]-w[to]));
add(from,to+n,x);
//前白后黑
}
}
}
}
int main(){
init();
spfa(1);
printf("%d",min(dis[n],dis[2*n]));//两个n结点选最小值
return 0;
}
（集训模拟赛12）道路和航线（奇怪的最短路）（洛谷P3008）
这道题显然就是一个最短路，但是这个最短路还不能乱跑：
题目中数据范围边数50000，显然nlogn是可以跑过，但是这道题有负权边，没办法直接跑Dij，怎么办呢（不要跟我说SPFA，它已经死了）
所以这道题我们要通过一些奇奇怪怪的方法，让他能跑Dij。（就是缩点+拓扑排序啦）
分析：
根据题目条件，我们知道道路是双向的且没有负权，航线是单向的但不存在于环中（没有一条航线可以通过其他道路或航线回来）。
我们可以对于每一堆双向的道路们，把它们缩在一起成为一个“联通块”，这样我们就可以在联通块内部跑Dij了，因为没有负权。
对于联通块之间的边，它们只能是航线，而且满足联通块之间没有环，那么：
我们可以通过跑拓扑序的方式来遍历每一个联通块。
正确性？
对于Dij来说，最开始除了起点，其它点的距离都被我们认为是无穷大，那么除了包含起点的联通块，其他联通块里所有点的值都是无穷大，对于这些块与起点块的关系有下面几种：
1.该联通块有一条航线指向起点块，那么由于航线的性质，该联通块内的点相对于起点来说肯定是“不可到达”的，那先遍历它也没什么问题。
2.该联通块被起点块指向，那么这个联通块内至少有一个点会被起点块中的点更新，那么它一定要排在起点块后遍历才能做到更新其内点的值不是无穷大。
3.类似上面的情况，只有所有指向一个块的块们都遍历过了，才会把这个块上该更新的点都更新过了，而且这样跑完之后，一定不会再有别的航线更新这个块了，这么遍历不就是拓扑序遍历吗！（先找入度为0的块，每遍历一条航线，那这条航线指向的块入度--，如果入度为0了，再遍历这个点）
拓扑序部分：
for(int i=1;i<=p;i++){
int from,to,val;
scanf("%d%d%d",&from,&to,&val);
add(from,to,val);
indegree[belong[to]]++;
//这是在读入每一条航线的时候就处理入度了，belong[to]表示to所在的联通块
}
for(int i=1;i<=belongcnt;i++){
if(indegree[i]==0)qq.push(i);
}//qq是储存入度为0的联通块的队列
while(!qq.empty()){
int x=qq.front();qq.pop();
Dij(x);
}
//在Dij里面我们会处理减入度的情况
void Dij(){
if(belong[to]!=x){
indegree[belong[to]]--;
if(indegree[belong[v]]==0)qq.push(belong[v]);
}
}
附上全部代码：
#include<bits/stdc++.h>
using namespace std;
const int maxn=1e6+10;
int n,m,p,s;
int belong[maxn],belongcnt;
vector<int> be[maxn];//这个向量里面保存的是某个联通块里面的所有点
struct E{
int from,to,val,next;
}edge[maxn];
int head[maxn],tot;
void add(int from,int to,int val){
edge[++tot].from=from;
edge[tot].to=to;
edge[tot].val=val;
edge[tot].next=head[from];
head[from]=tot;
}
void dfs(int u){
belong[u]=belongcnt;
be[belongcnt].push_back(u);
for(int i=head[u];i;i=edge[i].next){
int v=edge[i].to;
if(!belong[v])dfs(v);
}
}
int indegree[maxn];
queue<int> qq;
struct Node{
int num,dis;
Node(){}
Node(int x,int y){
num=x,dis=y;
}
bool operator <(const Node &aa)const{
return dis>aa.dis;
}
};
priority_queue<Node> q;
int dis[maxn];
void Dij(int x){
int size=be[x].size();
for(int i=0;i<size;i++){
int now=be[x][i];
//先把联通块中的所有点放入
q.push(Node(now,dis[now]));
}
while(!q.empty()){
Node ding=q.top();q.pop();
int u=ding.num,V=ding.dis;
if(dis[u]!=V)continue;//这个点的dis值已经被别的更新过了，才会造成这俩不一样
for(int i=head[u];i;i=edge[i].next){
int v=edge[i].to;
if(belong[v]!=x){//这个点不属于当前的联通块，肯定是航线
indegree[belong[v]]--;
if(indegree[belong[v]]==0)qq.push(belong[v]);
//这条航线指向的联通块入度--
}
if(dis[u]<0x3f3f3f3f&&dis[v]>dis[u]+edge[i].val){
dis[v]=dis[u]+edge[i].val;
if(belong[v]==x)q.push(Node(v,dis[v]));
//先把这个联通块的点都跑完，只入队这个联通块里面的点
}
//如果u的dis值还是无穷大呢，那就不用更新v了（小小的优化）
}
}
}
int main(){
memset(dis,0x3f,sizeof(dis));
scanf("%d%d%d%d",&n,&m,&p,&s);
dis[s]=0;
for(int i=1;i<=m;i++){
int from,to,val;
scanf("%d%d%d",&from,&to,&val);
add(from,to,val);add(to,from,val);
}
for(int i=1;i<=n;i++){
if(!belong[i]){
belongcnt++;
dfs(i);
}
}//在没读入航线之前，所有的道路们各自为战，不相联通，直接dfs就可求出联通块
for(int i=1;i<=p;i++){
int from,to,val;
scanf("%d%d%d",&from,&to,&val);
add(from,to,val);
indegree[belong[to]]++;
}
for(int i=1;i<=belongcnt;i++){
if(indegree[i]==0)qq.push(i);
}
while(!qq.empty()){
int x=qq.front();qq.pop();
Dij(x);
}
for(int i=1;i<=n;i++){
if(dis[i]==0x3f3f3f3f)printf("NO PATH\n");
else printf("%d\n",dis[i]);
}
return 0;
}
（dark假期集训%拟赛1）假面舞会（思维图论）（洛谷P1477）
题目：
思路：
这道题目的描述比较复杂，但是实际上我们可以把其中的情况分为以下几种：
1.只有环：
如果几个人构成了一个环，那么这个环上的结点个数的因数就是可能的面具总数。（如果一个环上每个人戴不同面具，那么面具总数就是人数，类似的，我们可以把这个环的人们分成几部分，每一部分人数相等且人人相连，这每一部分的人数也可能是面具的数量，整个环只是这几个面具的循环而已）
例如：
1->2->3->4->5->6->1
可能每个人面具都不同，也可能123面具各不相同，456分别与1、2、3面具相同。
如果这个图里有多个环，那么面具数量最大值就是这些环结点数的最大公约数，最小值就这个数大于等于3的最小因数。
2.只有链：
因为一个链首尾不相连，我们可以认为这个链上任何一个点的面具都不相同，那么面具数量最大值就是链上的结点数。
如果有多个互不相交的链，那么完全可以认为所有人的面具都不一样，最大面具数量就是人数。如果相交，那么一个链集合的最大面具数是其中最长的那条链的长度（原因请看4.中的判链部分）。
我们也可以把链上的所有人看作三个面具（题目所给最小值）的不断循环，而且无论链多长，有几个链，都是可以满足的。
1->2->3->4->5 6->7
如图，面具最大值是7，最小值是3 （1->2->3->1->2 1->2）
3.有环有链：
我们知道，有环的话，那么就会出现面具数量的限制（环的结点数是面具最大值，>=3的最小因数是最小值）
而单独的链是不会出现此类限制，最大的要多少有多少，最小的直接就是3，那么我们可以这样认为：环的限制比链的限制范围要小。（环造成的限制链都能满足，链造成的限制环不一定能满足）那么我们就可以知道在环链同时存在的时候，我们只需要处理环就可以了。
4.不成立的情况
我们根据题目中所描述，可以知道：当多个人能看到同一个人的时候，这“多个人”面具编号一定一样，一个人能看到多个人的时候，这“多个人”面具编号也一样。只有在同一个人看到的“多个人”编号不同或看到同一个人的“多个人”编号不同时，属于“不成立”的情况，要输出“-1 -1”。
我们通过正向建边权值为1，反向建边权值-1的方法来处理这种情况，我们对每个点维护他的深度。
我们可以这么考虑，对于一个点，他指向的（也就是这个人能看到的人们）点的dep值是这个点+1，指向他的（也就是看到这个人的人们）的dep值是这个点-1，这样就能保证刚才所说的条件了，我们可以在判环判链的过程中顺便处理这个问题。
1.判环过程中：通过对每一个我们构建的“联通区域”进行dfs，我们可以得到一些环，在这个过程中，我们如果访问了一个之前访问过的点，那么我们就找到了一个环，我们就把它加到我们的求gcd的数里面，对于不成立的情况，他们的环的大小就会是3以下，在后期的处理中我们可以判掉。
void dfs_huan(int u){
vis[u]=1;
for(int i=head[u];~i;i=edge[i].next){
int v=edge[i].to;
if(!vis[v]){
dis[v]=dis[u]+edge[i].val;
dfs_huan(v);
}else{
ans=gcd(ans,abs(dis[u]-dis[v]+edge[i].val));
}
}
}
int main(){
for(int i=1;i<=n;i++){
if(!vis[i]){
dfs_huan(i);
}
}
if(ans!=0){
if(ans<3){
printf("-1 -1\n");
return 0;
}else{
int i;
for(i=3;i<=ans;i++){
if(ans%i==0){
break;
}
}
printf("%d %d\n",ans,i);
return 0;
}
}
return 0;
}
若出现1->2(权值为1)2->1（权值-1）的环，我们在处理的时候会把他的环大小变为（1-0-1=0），而0与任何数的公因数都是任何数，不会造成影响。
对于其他的“不成立”情况，可以根据这个代码自行模拟一下，很快就会发现他的正确性。
2.判链过程中：
对于链，只有一种不成立的情况，就是链本身的长度小于3，这种情况我们就好判了：
Min保存的是这个点向前延伸的最远长度（负数），Max保存的是这个点向后延伸的最远长度，两者一减，再加上这个点自己，就是这条链的长度，我们记录所有链的长度之和。我们在这里没有直接输出所有点数的原因是，同一个点有可能处于多条链的交汇处，而根据题目条件，一个点指向的所有点和指向一个点的所有点编号相同，不能认为每一个人的面具都不同，而是一个“单链”中的面具都不同，我们自然要保存每一组相交的单链中最长的那个。
void dfs_lian(int u){
vis[u]=1;
Max=max(Max,dis[u]);
Min=min(Min,dis[u]);
for(int i=head[u];~i;i=edge[i].next){
int v=edge[i].to;
if(!vis[v]){
dis[v]=dis[u]+edge[i].val;
dfs_lian(v);
}
}
}
int main(){
for(int i=1;i<=n;i++){
if(!vis[i]){
Max=Min=dis[i]=0;
dfs_lian(i);
ans+=Max-Min+1;
}
}
if(ans>=3){
printf("%d 3\n",ans);
}else printf("-1 -1\n");
return 0;
}
下面附上全代码：
#include<bits/stdc++.h>
using namespace std;
const int maxn=2e6+20;
int n,m;
struct E{
int to,val,next;
}edge[maxn];
int head[maxn],tot;
void add(int from,int to,int val){
edge[++tot].to=to;
edge[tot].val=val;
edge[tot].next=head[from];
head[from]=tot;
}
int gcd(int x,int y){
if(y==0)return x;
if(x==0)return y;
if(x%y==0)return y;
return gcd(y,x%y);
}
int vis[maxn],dis[maxn],ans;
void dfs_huan(int u){
vis[u]=1;
for(int i=head[u];~i;i=edge[i].next){
int v=edge[i].to;
if(!vis[v]){
dis[v]=dis[u]+edge[i].val;
dfs_huan(v);
}else{
ans=gcd(ans,abs(dis[u]-dis[v]+edge[i].val));
}
}
}
int Max,Min;
void dfs_lian(int u){
vis[u]=1;
Max=max(Max,dis[u]);
Min=min(Min,dis[u]);
for(int i=head[u];~i;i=edge[i].next){
int v=edge[i].to;
if(!vis[v]){
dis[v]=dis[u]+edge[i].val;
dfs_lian(v);
}
}
}
int main(){
scanf("%d%d",&n,&m);
memset(head,-1,sizeof(head));
for(int i=1;i<=m;i++){
int from,to;
scanf("%d%d",&from,&to);
add(from,to,1);
add(to,from,-1);
}
for(int i=1;i<=n;i++){
if(!vis[i]){
dfs_huan(i);
}
}
if(ans!=0){
if(ans<3){
printf("-1 -1\n");
return 0;
}else{
int i;
for(i=3;i<=ans;i++){
if(ans%i==0){
break;
}
}
printf("%d %d\n",ans,i);
return 0;
}
}
memset(vis,0,sizeof(vis));
ans=0;
for(int i=1;i<=n;i++){
if(!vis[i]){
Max=Min=dis[i]=0;
dfs_lian(i);
ans+=Max-Min+1;
}
}
if(ans>=3){
printf("%d 3\n",ans);
}else printf("-1 -1\n");
return 0;
}
（dark假期集训%拟赛2）Layout（差分约束）（洛谷P4878）
这算比较基础的差分约束题目了。
比较明显的约束关系：
a牛与b牛互相爱慕：d[b]-d[a]<=z（b在a后面）
a牛与b牛互相讨厌：d[b]-d[a]>=z (b在a后面)
编号小的牛要在编号编号大的牛前面：d[i]-d[i-1]>=0
题目要求1到n的最大值，我们全部转化成<=,求最短路即可
这里还有一个问题，就是有可能从1开始spfa并不能遍历到每一个点（图不联通），而在与1不联通的地方有可能存在负环，我们想解决这个问题，只需要建一个虚拟的超级源点，由他向每一个点建边，这样再跑它的spfa就可以找全图的负环了，没有负环再跑spfa（1）找结果即可。
代码：
#include<bits/stdc++.h>
using namespace std;
const int maxn=50010;
struct E{
int to,val,next;
}edge[maxn];
int head[maxn],tot;
void add(int from,int to,int val){
edge[++tot].to=to;
edge[tot].val=val;
edge[tot].next=head[from];
head[from]=tot;
}
int n,m,k,flag;
int dis[maxn],vis[maxn],cnt[maxn];
queue<int> q;
void spfa(int s){
memset(dis,0x3f,sizeof(dis));
memset(vis,0,sizeof(vis));
memset(cnt,0,sizeof(cnt));
dis[s]=0;
q.push(s);
while(!q.empty()){
int u=q.front();q.pop();vis[u]=0;
for(int i=head[u];i;i=edge[i].next){
int v=edge[i].to;
if(dis[v]>dis[u]+edge[i].val){
dis[v]=dis[u]+edge[i].val;
if(!vis[v]){
if(++cnt[v]>n){
flag=-1;
return;
}
vis[v]=1;q.push(v);
}
}
}
}
if(dis[n]==0x3f3f3f3f)flag=-2;
}
int main(){
scanf("%d%d%d",&n,&m,&k);
for(int i=1;i<=m;i++){
int from,to,val;
scanf("%d%d%d",&from,&to,&val);
if(from>to)swap(from,to);
add(from,to,val);
}//互相爱慕的牛我们由较小编号的向较大编号的建正权边
//d[to]-d[from]<=val 我们由from向to建边（视个人喜好）
for(int i=1;i<=k;i++){
int from,to,val;
scanf("%d%d%d",&from,&to,&val);
if(from>to)swap(from,to);
add(to,from,-val);
}//互相讨厌的牛我们由较大编号的向较小编号的建负权边
//d[to]-d[from]>=val------->d[from]-d[to]<=-val我们由to向from建边
for(int i=2;i<=n;i++){
add(i,i-1,0);
}//d[i]-d[i-1]>=0-------->d[i-1]-d[i]<=0我们由i向i-1建边
//上面这三个无所谓谁向谁建边，只要三个保持一致就好了（指减号前面的都在有向边的同一侧）
//像这样建边我们spfa（1）找dis[n]，如果反着来spfa（n）找dis[1]即可。
for(int i=1;i<=n;i++){
add(0,i,0);
}//超级源点（0）向所有点建边
spfa(0);
if(flag==-1){
printf("-1");
return 0;
}
spfa(1);
if(flag==-1)dis[n]=-1;
if(flag==-2)dis[n]=-2;
printf("%d",dis[n]);
return 0;
}
（dark假期集训%拟赛2）游戏（反向并查集）
题目：
分析：
我们从题目中可以发现：每一个点只有一个出边。这类似与我们的并查集的父亲结点，每一个点的父亲结点只有一个。所以这道题我们可以用并查集做。
1.通过Find操作，我们可以找到一个点的最早祖先，也就是这个点最后停止的点，如果有环的话特判一下。
2.可是这道题是边查边删除边的，所以我们需要用一个并查集技巧：离线并查集之删边等于倒着加边大概就是正着删除边等于倒着加边，我们可以倒序处理这些查询，先在输入的时候把该删的边全删掉，再倒着加回来，边加边查。至于为什么不能边删边查，是因为并查集的优化中有一个路径压缩，它会打破之前所建的边的关系，但是不影响结果，删边操作不满足路径压缩，加边是满足的（就是加边之后原来的祖先还是祖先，顶多不是最早的，但是删边之后，你的祖先有可能就不是你的祖先了）。
上代码：
#include<bits/stdc++.h>
using namespace std;
const int maxn=3e5+10;
int fa[maxn],n,q,Time,res[maxn],now[maxn],mode[maxn],ans[maxn];
int find(int x,int Time){
if(Time>n){
return fa[x]=0;
}
//判环的特判：如果循环的次数大于n，一定有环。
//fa[x]=0的作用是把这个环从这里断开，避免以后重复判环造成时间冗余（不这么些你就T了）
//以后的点再判到这个环时，会到这个断点，然后再运行到fa[0]=0，这样就表示有环了，与下面的环的特判相结合
if(fa[x]==x)return x;
else return fa[x]=find(fa[x],Time+1);
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++){
int xx;
scanf("%d",&xx);
if(xx==0)fa[i]=i;
else res[i]=fa[i]=xx;
}//因为回头要加边，所以先保存一下每个点的父亲
scanf("%d",&q);
for(int i=1;i<=q;i++){
scanf("%d%d",&mode[i],&now[i]);
if(mode[i]==2){
fa[now[i]]=now[i];
//删边
}
}
int cnt=0;
for(int i=q;i>=1;i--){
if(mode[i]==1){
ans[++cnt]=find(now[i],0);
//加入答案中
}else{
fa[now[i]]=res[now[i]];
//恢复边
}
}
for(int i=cnt;i>=1;i--){
if(ans[i]==0)printf("CIKLUS\n");//环
else printf("%d\n",ans[i]);
}
//倒着保存的，所以要倒着输出才是正过来的答案
return 0;
}
（dark假期集训%拟赛3）乘车路线（二维限制最短路）
题目：
基本就是最短路板子了，但是又多了一个限制条件，根据隔壁dp的尿性，多一个限制就多一维呗
我们定义dp[i][j](串味了),dis[i][j]表示i点在花j的费用的条件下距离起点的最短距离。
我们的spfa也需要作出一些改变，队列里面保存的不只是点的编号，还有它到起始点的花费。比较的时候也要特判当前的cost是否已经超过了限制的花费。
上代码：
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=100010;
int n,m,w;
struct E{
int from,to,v,c,next;
}edge[maxn];
//既然是二维了，那么建边的时候也要多一个变量
int head[1100],tot;
void add(int from,int to,int v,int c){
edge[++tot].to=to;
edge[tot].v=v;
edge[tot].c=c;
edge[tot].next=head[from];
head[from]=tot;
}
struct Node{
int node,cost;
//node表示点的编号，cost表示点的花费
Node(){}
Node(int x,int y){
node=x;cost=y;
}
};
int dis[1100][1100],vis[1100][1100],Min=0x7fffffff;
queue<Node> q;
//dis、vis数组都变成二维，队列也多保存一个花费
void spfa(int s){
memset(dis,0x3f,sizeof(dis));
dis[s][0]=0;
//起点花费和距离肯定都是0
q.push(Node(s,0));
while(!q.empty()){
Node u=q.front();q.pop();vis[u.node][u.cost]=0;
for(int i=head[u.node];i;i=edge[i].next){
int v=edge[i].to;
int val=edge[i].v,c=edge[i].c;
if(u.cost+c>w)continue;//超出费用限制直接continue掉
if(dis[v][u.cost+c]>dis[u.node][u.cost]+val){//当前花费是上一个点的花费+这条边的花费
dis[v][u.cost+c]=dis[u.node][u.cost]+val;//其他部分跟spfa没啥区别
if(!vis[v][u.cost+c]){
q.push(Node(v,u.cost+c));
vis[v][u.cost+c]=1;
}
}
}
}
}
int main(){
scanf("%d%d%d",&w,&n,&m);
for(int i=1;i<=m;i++){
int from,to,v,c;
scanf("%d%d%d%d",&from,&to,&v,&c);
add(from,to,v,c);
}
spfa(1);
for(int i=0;i<=w;i++){
Min=min(Min,dis[n][i]);
//在到终点的不同花费中找最小的路程
}
if(Min==0x3f3f3f3f){
printf("NO\n");
return 0;
}
printf("%d",Min);
return 0;
}
最近集训的图论（思路+实现）题目汇总（内容包含tarjan、分层图、拓扑、差分、奇怪的最短路）：的更多相关文章
- leetcode - 位运算题目汇总(下）
接上文leetcode - 位运算题目汇总(上),继续来切leetcode中Bit Manipulation下的题目. Bitwise AND of Numbers Range 给出一个范围,[m, ...
- 2016年Web前端面试题目汇总
转载: 2016年Web前端面试题目汇总 以下是收集一些面试中经常会遇到的经典面试题以及自己面试过程中未解决的问题,通过对知识的整理以及经验的总结,重新巩固自身的前端基础知识,如有错误或更好的答案,欢 ...
- 前端面试题目汇总摘录（JS 基础篇）
JS 基础 JavaScript 的 typeof 返回那些数据类型 object number function boolean undefined string typeof null; // o ...
- 力扣题目汇总（重复N次元素，反转字符串，斐波那契数)
重复 N 次的元素 1.题目描述 在大小为 2N 的数组 A 中有 N+1 个不同的元素,其中有一个元素重复了 N 次. 返回重复了 N 次的那个元素. 示例 1: 输入:[1,2,3,3] 输出:3 ...
- 力扣题目汇总（反转字符串中的单词，EXCEL表列序号，旋置矩阵）
反转字符串中的单词 III 1.题目描述 给定一个字符串,你需要反转字符串中每个单词的字符顺序,同时仍保留空格和单词的初始顺序. 示例 1: 输入: "Let's take LeetCode ...
- LeetCode 11月第2周题目汇总
开源地址:点击该链接 前言 最近比较忙,这周几乎没有刷题,只刷了6道题~ 题目汇总 0387_first_unique_character_in_a_string类似的题目比较多了,字符串中找出特别的 ...
- All LeetCode Questions List 题目汇总
All LeetCode Questions List(Part of Answers, still updating) 题目汇总及部分答案(持续更新中) Leetcode problems clas ...
- 2019暑期金华集训 Day3 图论
自闭集训 Day3 图论 NOI2019 D2T1 没有真正建出图来的必要,可以直接打取\(\min\)的\(tag\). 也可以把边压进堆里,然后变成一个二维清点问题(???),然后就线段树+并查集 ...
- Python—经典练手题目汇总
Python-经典练手题目汇总 # 1.有1020个西瓜,第一天卖掉总数的一半后又多卖出两个,以后每天卖剩下的一半多两# 个,问几天以后能卖完? day=0 xg=1020 for i in rang ...
随机推荐
- oracle之三rman 备份
rman 备份 7.1 归档方式下rman备份常用语法: 7.1.1 backup 备份 1)备份全库:1.1 RMAN> backup database format='/u01/myrman ...
- appium的基本环境配置
1.先安装jdk1.7或jdk1.8之后,并配置好环境变量 2.安装Android SDK(安卓软件开发包),测试Android手机必然要安装Android SDK,例如android-sdk_r24 ...
- 反序列化之PHP
反序列化漏洞 #PHP反序列化 原理:未对用户输入的序列化字符串进行检测,导致攻击者可以控制反序列化过程,从而导致代码执行,SQL注入,目录遍历等不可控后果.在反序列化的过程中自动触发了某些魔术方法. ...
- [程序员代码面试指南]递归和动态规划-换钱的方法数（DP，完全背包）
题目描述 给定arr,arr中所有的值都为正数且不重复.每个值代表一种面值的货币,每种面值的货币可以使用任意张,再给定一个整数aim,求组成aim的方法数. 解题思路 完全背包 和"求换钱的 ...
- 云计算openstack——虚拟机获取不到ip（13）
一.现象描述: openstack平台中创建虚拟机后,虚拟机在web页面中显示获取到了ip,但是打开虚拟机控制台后查看网络状态,虚拟机没有ip地址,下图为故障截图: 二.分析思路: (1)查看neut ...
- 【转】PostgreSQL Index性能调优
Index(索引)这个概念对于很多熟悉关系型数据库的人来说,不是一个陌生的概念.当表中数据越来越多时,在查询时,为了避免全表查询(sequence scan)可以在查询相关的条件字段上添加索引.举例来 ...
- Jaskson精讲第6篇-自定义JsonSerialize与Deserialize实现数据类型转换
Jackson是Spring Boot(SpringBoot)默认的JSON数据处理框架,但是其并不依赖于任何的Spring 库.有的小伙伴以为Jackson只能在Spring框架内使用,其实不是的, ...
- 消息队列之事务消息，RocketMQ 和 Kafka 是如何做的？
每个时代,都不会亏待会学习的人. 大家好,我是 yes. 今天我们来谈一谈消息队列的事务消息,一说起事务相信大家都不陌生,脑海里蹦出来的就是 ACID. 通常我们理解的事务就是为了一些更新操作要么都成 ...
- tomcat源码--springboot整合tomcat源码分析
1.测试代码,一个简单的springboot web项目:地址:https://gitee.com/yangxioahui/demo_mybatis.git 一:tomcat的主要架构:1.如果我们下 ...
- Vue学习笔记使用系列一【表单】
脚手架的搭建,请查看另外一篇日记:https://www.cnblogs.com/Fengge518/p/11837078.html 1:直接代码了 1 <!DOCTYPE html> 2 ...