围巾的ACM博客

思路：一个有向图要求来回的最短路，一个经典的做法是保存一个原图，一个边取反的图，然后跑两遍spfa就可以了#include#include#include#include#includeusing namespace std;const int maxn = 1005;#define inf 1e9vector >e1[maxn];vector >e2[maxn];

思路：先求一次最短路把最短路上的边都弄出来之后加进网络流里，连一条容量为1的边即可#includeusing namespace std;const int maxn = 2005;#define inf 1e9#define INF 1e9const int maxm = 4000000+50;struct Node{ int v,w; Node(int vv,in

思路：给你m个交换条件就是相当于m条路，然后求一发最短路就可以了#includeusing namespace std;const int maxn = 10000+500;int d[maxn];struct Node{ int x,y; Node(){}; Node(int xx,int yy):x(xx),y(yy){};};vectore[maxn];in

思路：由于数据范围比较小，我们直接对于每一个点来求最短路，然后枚举看看移动T个最多能去到哪里就好了#includeusing namespace std;int n,m,t;int mp[35][35];double ans = 0;int d[35][35];int inq[35][35];int dir[4][2]={{0,1},{0,-1},{1,0},{-1,0}

思路：大概看样例就知道了，跑一次floyd然后直接枚举就好了，注意自己转到自己是不需要花费的#includeusing namespace std;#define LL long longLL e[30][30];char s[1000000+500];int main(){ for(int i = 0;i<26;i++) for(int j = 0;j<26;j++

思路：把容量排序之后，二分容量然后最短路check就好了#includeusing namespace std;#define LL long longconst int maxn = 10000+500;int n,m,t;struct Node{ int v,t; LL c; Node(){}; Node(int vv,LL cc,int tt):v(vv),c

思路：模板题#includeusing namespace std;const int maxn = 205;#define INF 1e9vector >e[maxn];int d[maxn];void init(int n){ for(int i = 0;i<=n;i++) e[i].clear(); for(int i = 0;i<=n;i++)

思路：显然直接的最短路是不可行的，因为可以选择k条路是免费的，那么我们可以在dijkstra转移的时候多加一维，令d[i][j]为走到i结点已经用了j次免费次数的最小花费即可#includeusing namespace std;const int maxn = 10000+500;#define INF 1e9int n,m,k;vector >e[maxn];int

题意：给你一个边权为1的图，s1到t1最多不能超过l1时间，s2到t2最多不能超过l2时间，问你最多能删多少条边思路：首先因为边权为1，所以最短路的时间就是边数，那么可以直接枚举重复的区间然后相减即可#includeusing namespace std;const int maxn = 3005;#define INF 1e9vectore[maxn];int vis[

思路：令f[i]为到第i天的最少成本，那么显然有f[i]=min(f[i],f[j]+cost(j+1,i)+k)，其中cost(i,j)为i天到j天的最小花费，然后直接最短路搞Trick：INF不能开太大#includeusing namespace std;const int maxn = 205;vector >e[maxn];int d[maxn];int vis

思路：一个简单的传递闭包#include#include#includeusing namespace std;const int maxn = 105;int g[maxn][maxn];int main(){ int n,m; while(scanf("%d%d",&n,&m)==2) { memset(g,0,sizeof(g)); for(in

思路：最短路裸题#includeusing namespace std;const int maxn = 2505;#define INF 1e9vector >e[maxn];int d[maxn];void dijkstra(int s){ priority_queue >q; d[s]=0; q.push(make_pair(-d[s],s)); while

思路：比较麻烦的最短路#includeusing namespace std;const int maxn = 10005;const int INF = 1e9;vector >e[maxn];int n,m,k,ds;int d[maxn];int trans(string s){ int num = 0; if(s[0]=='G') { int p

思路：最短路裸题#includeusing namespace std;const int maxn = 205;const int INF = 1e9;int n,m;vector >e[maxn];int d[maxn];void init(){ for(int i = 0;i<maxn;i++) e[i].clear(); for(int i = 0;i<

思路：首先每次曹操从一个村庄调用一个兵到战场xi时，其实相当于同时往yi战场减少一个兵，如果yi战场的价值度是0的话那么是无所谓的，如果价值是2的话，那么这减少的一个兵你就要通过其他村庄转移来填补这一个减少的兵，否则就会输掉，那么这样一直转移到一个无用的战场，那么就可以满足条件了，所以按照这样建图然后跑一次最短路那么就是最少费用了（一开始以为是网络流什么的...大概数据范围也透露了一点...）

思路：任意点对之间的最短路#includeusing namespace std;const int maxn =1005;#define INF 1e9vectore[maxn];int d[maxn][maxn];mapmp;int vis[maxn];void spfa(int x){ memset(vis,0,sizeof(vis)); d[x][x]=0

思路：有点权和边权两个属性，求边权最小点权最大的最短路，dijkstra简单变形#includeusing namespace std;const int maxn = 505;const int INF = 1e9;int e[maxn][maxn],val[maxn],path[maxn],dis[maxn],ans[maxn],totval[maxn];int path

思路：一个很裸的0/1规划的题，没接触过的话很难会朝图论的方面去想，从前两个条件其实就是点1的出度为1，点n的入度为1，然后其他点的出度等于入度，边权就是它的费用，那么建图然后最短路就可以了，这里比较坑的是由于只说了出度为1，但入度不知道，所以可能存在两个环，从1出发回到1，从n出发回到n的情况#includeusing namespace std;#define inf 1e9

思路：一个有多层次的图，求1到n的最短路，把每一层图都拆成两个点，一个点入，一个点出，然后建图就好了，建图详见代码#includeusing namespace std;#define inf 1e9const int maxn = 3*1e5+7;vector >e[maxn];int d[maxn],inq[maxn],s,t,n,m,c;void spfa(){

思路：比较裸的差分约束，直接建图然后spfa就可以了#includeusing namespace std;const int maxn = 1005;#define inf 1e9int d[maxn];int inq[maxn];int cnt[maxn];int n,x,y;vector >e[maxn];int spfa(){ memset(inq,0,s

题意：给定n个城镇以及m条道路，每条道路连接两个城镇，道路有上下两种状态，求起点到终点需要的最少转换状态次数思路：令dp[i][0/1]为到达第i个城镇当前是上坡或者下坡的最少转换次数，然后无脑spfa就可以了#include#include#include#include#includeusing namespace std;const int maxn = 1000

思路：读错题。。比赛的时候没出来。。首先对每个点求一次最短路，然后枚举中间点，排序取前两个大的更新答案就可以了#includeusing namespace std;const int maxn = 1005;#define inf 1e9vector >e[maxn];int d[maxn][maxn];int vis[maxn];int res[maxn*2];in

思路：先跑一次最短路，然后把最短路上的边扔进网络流跑一次最小割就好了，和HDU3416异曲同工#includeusing namespace std;const int maxn = 2005;#define inf 1e9#define INF 1e9const int maxm = 4000000+50;struct Node{ int v,w; Node(int

题意：n个地铁站，m条线路，地铁站之间花费t时间，不属于同一条线路的地铁站需要“转站”，即加上一个额外花费w（w为线路代号的差值）。 求1到n的最短时间思路：由于有转站的影响，可以考虑将地铁站拆点，权值是他们的差值，或者直接以边作为点也是可以的#includeusing namespace std;const int maxn = 2e5+7;#define inf 1LL<

思路：学习了一波辛普森公式求积分 点击打开链接，然后就是套最短路模板就可以了....坑点：是有向图，看成了无向图WA了好多次#includeusing namespace std;#define inf 1e9#define eps 1e-8int n,m,T;struct Node{ int v,c,d; Node(){}; Node(int vv,int cc

思路：挺难的一道差分约束 见题解：点击打开链接#include #include #include #include #include using namespace std;const int inf = 0x3f3f3f3f;int r[30], t[30];int n; struct edge{ int v, cost; edge

思路：找平均值最大的环，将字符串前两个和最后两个当做两个结点，有一条边权值就是这个串的长度。           那么avg = (w1+w2+....wk)/k，把k乘过去有avg*k = (w1+w2+...wk)，然后有(w1-avg)+(w2-avg)+...(wk-avg)>=0，然后其实就是要求(w1-ans)+(w2-ans)+...(wk-ans)>0，二分ans然后求正环。

思路：和HDU3440基本一样....#include#include#include#include#include#includeusing namespace std;const int maxn = 1005;#define inf 1e9struct Node{ int h,id;}hou[maxn];bool cmp(Node a,Node b){

思路：读懂题之后的差分约束#includeusing namespace std;const int maxn = 1005;#define inf 1e9struct Node{ int h,id;}hou[maxn];bool cmp(Node a,Node b){return a.h<b.h;}vector >e[maxn];int inq[maxn],d[m

思路：一个很经典的题目，求补图的最短路，方法是建原图，然后用两个set维护还没 BFS 过的点。当要扩展点 u 的时候，遍历一次还没访问过的点 v，如果 uv 没边，那么将 v 入队。否则将 v 留在未扩展点中。#includeusing namespace std;const int maxn = 200000+7;vectore[maxn];int n,m,s,dis[ma

题意：给一个 n*m 的矩阵，问是否能够给每行乘以一个数 Xi，给每列除以一个数 Yj（两行两列之间可以不同），使得最后矩阵中所有元素的值在区间 [L,U] 内思路：这里的话有除法不好处理，所以两边直接取对数，转化为d[ai]>=d[bi]+log(l/cij),d[bj]>=d[ai]-log(r/cij)这样求最长路或者求最短路也是可以的，代码里面用的是求最短路的方法，然后只是找环的话用D

思路：这个题目真是难读....下面的题解转别人的现在假设有一个这样的序列，S={a1，a2，a3，a4...ai...at}其中ai=a*si,其实这句可以忽略不看现在给出一个不等式，使得ai+a(i+1)+a(i+2)+...+a(i+n)ki首先给出两个数分别代表S序列有多少个，有多少个不等式不等式可以这样描述给出四个参数第一个数i可以代表序列的第几项，然后给出

思路：和POJ1716基本一样，只是这里区间不同元素的个数也给了而已#include#include#include#includeusing namespace std;#define inf -1e9const int maxn = 50005;vector >e[maxn];int d[maxn],cnt[maxn],inq[maxn],n;int spfa(i

题意：给你一些区间，问你确定一个集合，使得这个集合和这些区间至少有两个数字相同，求这个集合最小元素个数思路：令d[i]为0到i区间的不同元素个数，那么有d[b]-d[a-1]>=2，d[i+1]>=d[i]，d[i]>=d[i+1]-1,d[i]>=d[0]，然后建边跑最长路求最小值就可以了，这里区间从0开始计数，我就都++了，如果不++的话那么要变成d[b+1]-d[a]>=2，这样跑了98

思路：从题目已知一些A和B的距离已知，那么就可以得d[A]-d[B]=X，并且有一些边只知道大小关系的就是d[A]-d[B]>=1，然后建图最短路就可以了#include#include#include#includeusing namespace std;const int maxn = 1005;#define inf 1e9vector >e[maxn];int

思路：一道差分约束最长路求最小值，读懂题目连边求一次最长路就可以了#includeusing namespace std;const int maxn = 10010;#define inf 1e9vector >e[maxn];int d[maxn],inq[maxn],a[maxn],cnt[maxn];int n;int spfa(){ memset(inq,0

题意：给你一个完全图，里面的边不是火车道就是汽车道，然后任意时刻，火车和汽车都不能相遇在除了1，n的其他点每条边的边权值都是1，然后问你最小时间使得两种车都能到达n点思路：只要留意到是完全图就很好做了，那么总有一种车可以只花费1就能从起点走到终点，然后剩下那个车跑一发最短路就好了#includeusing namespace std;#define INF 1e9int

思路：把恶心的题目看完...然后就是floyd裸题了#include #include #include #define inf 0x3f3f3f3fusing namespace std;int mmap[100][100],n;void floyd() { for(int k=1; k<=20; k++) for(int i=1; i<=20; i++)

题意：给定一个图，可以在边和点上设立发射井，其中发射井到首都的距离必须等于L，问可以建多少个发射井思路：建图然后跑最短路，如果发射井在边上的话，画个图可以知道限制的条件（利用三角不等式），如果发射井在点上的话只需要判是否等于L即可,见代码#include #include #include #include #include #include #includ

题意：去机场有经济线和商业线这两种火车可以选择，现在你有一张商业线的火车票，可以坐一站，其余时候只能坐经济线，问去机场的最快路线，并且打印路径思路：我们假设从a到b坐的是商业线，那么最短时间就是从起点出发到a的最短路径+a到b的时间+b到终点的最短路径，首先对起点和终点分别跑一遍最短路，然后枚举每一点，维护ans最少，路径递归输出即可Trick：这个题输出格式真的是要醉了..两个样例之间输