SPFA(Shortest Path Faster Algorithm)
特别说明
本文转载自三金（frinemore）的博客： 点这
前言
1.关于SPFA，它没死。
2.接下来的所有代码，都是自己手写的（未检查正确性,补充的代码有检查过,是对的），有错误请帮忙指出。
SPFA原理及正确性
若给定的图存在负权边，类似Dijkstra算法等算法便没有了用武之地，SPFA算法便派上用场了。简洁起见，我们约定加权有向图G不存在负权回路，即最短路径一定存在。用数组d记录每个结点的最短路径估计值，而且用邻接表来存储图G。我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。
定理：只要最短路径存在，上述SPFA算法必定能求出最小值。证明：每次将点放入队尾，都是经过松弛操作达到的。换言之，每次的优化将会有某个点v的最短路径估计值d[v]变小。所以算法的执行会使d越来越小。由于我们假定图中不存在负权回路，所以每个结点都有最短路径值。因此，算法不会无限执行下去，随着d值的逐渐变小，直到到达最短路径值时，算法结束，这时的最短路径估计值就是对应结点的最短路径值。
其实可以这样理解：
在给定一个不存在负权回路的图中，有n个节点，m条边
那么在求某点（假设此点为1）单源最短路时，到最远点的距离最多经历n-1条边。
那么用m条边进行n-1次松弛就可以求出最短路了。
下面是Bellman——Ford Algorithm:
const int MAXNC = 10000;
struct edge {
int x, y, val;
}a[MAXNC];
for(int i = 1; i < n; i++)
for(int j = 1; j <= m; j++) {
int x = a[j].x, y = a[j].y;
if(d[y] > d[x] + a[j].val) d[y] = d[x] + a[j].val;
}
判负环：
bool have_negetive_circle = false;
for(int i = 1; i<= m; i++) {
int x =a[i].x, y = a[i].y;
if(d[y] > d[x] + a[i].val) {
have_negetive_circle = true;
break;
}
}
if(have_negetive_circle) printf("...");
优化
由于传统算法时间复杂度很高（o（n * m））,所以得优化一下。
宽搜优化
因为只有d值被更新的结点的出度才能更新其他节点的d值，所以我们可以用队列（queue）优化。
这是代码：
void SPFA(int s) {
queue<int> Q;
for(int i = 1; i <= n; i++) d[i] = INF;
d[s] = 0;
Q.push(s);
while(!Q.empty()) {
int x = Q.front(); Q.pop();
inq[x] = false;
for(int i = 1; i; i = a[i].next) {
int y = a[i].y;
if(d[y] > d[x] + a[i].val) {
d[y] = d[x] + a[i].val;
if(!inq[y]) Q.push(y);
}
}
}
}
不过20行代码。
SPFA队列判负环
只需要在入队是记录次数就好了，如果大于了n，说明有负环。
code：
bool SPFA(int s) {
queue<int> Q;
for(int i = 1; i <= n; i++) d[i] = INF, cnt[i] = 1;
d[s] = 0; cnt[s] = 1;
Q.push(s);
while(!Q.empty()) {
int x = Q.front(); Q.pop();
inq[x] = false;
for(int i = 1; i; i = a[i].next) {
int y = a[i].y;
if(d[y] > d[x] + a[i].val) {
d[y] = d[x] + a[i].val;
if(!inq[y]) {
Q.push(y);
inq[y] = true;
if(++cnt[y] > n) return true;
}
}
}
}
return false;
}
其实就在原有代码上改了一点，但这有个缺点，就是只能找从源点s出发的负环，如果s不能到达负环，那么这个是检查不出来的。
这个问题当然是有办法解决的，下面是代码。
code：
bool have_negative_circle() {
queue<int> Q;
for(int i = 1; i <= n; i++) d[i] = 0, cnt[i] = 1, inq[i] = true, Q.push(i);
//d[i] = 0,这样更容易找负环，效率更高
while(!Q.empty()) {
int x = Q.front(); Q.pop();
for(int i = head[x]; i; i = a[i].next) {
int y = a[i].y;
if(d[y] > d[x] + a[i].val) {
d[y] = d[x] + a[i].val;
if(!inq[y]) {
inq[y] =true;
Q.push(y);
if(++cnt[y] >= n) return true;
}
}
}
}
return false;
}
这个代码的效率要比上面的高多了，但只能找负环。
深搜优化：
我也只是知道有这个优化，但具体不清楚，不过我旁边的那位大神犇有仔细研究过，让他来讲。
基于 dfs 版的 SPFA 相当于是把"先进先出"的队列换成了"先进后出"的栈
也就是说，每次都以刚刚松弛过的点来松弛其他的点，如果能够松弛点 x 并且 x 还在栈中，那图中就有负环
一般来说的话，若存在负环，那么 dfs 会比 bfs 快
但是如果不存在负环，dfs 可能会严重影响求最短路的效率，要谨慎使用
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 10005
#define M 20005
using namespace std;
int n,m,t;
int d[N],first[N];
int v[M],w[M],next[M];
bool flag,vis[N];
void add(int x,int y,int z)
{
t++;
next[t]=first[x];
first[x]=t;
v[t]=y;
w[t]=z;
}
void spfa(int x)
{
int i,j;
vis[x]=true;
for(i=first[x];i;i=next[i])
{
j=v[i];
if(d[j]>d[x]+w[i])
{
if(vis[j])
{
flag=false;
return;
}
d[j]=d[x]+w[i];
spfa(j);
}
}
vis[x]=false;
}
int main()
{
int x,y,z,i;
scanf("%d%d",&n,&m);
for(i=1;i<=m;++i)
{
scanf("%d%d%d",&x,&y,&z);
add(x,y,z);
add(y,x,z);
}
memset(d,127,sizeof(d));
d[1]=0;
flag=true;
spfa(1);
if(!flag) printf("Yes");
else printf("No");
return 0;
}
深搜代码：作者：forever_dreams
原文：https://blog.csdn.net/forever_dreams/article/details/81161527
应用
下面介绍我所知道的SPFA应用。
求最短路
如果没有负权边，那么请用效率更高的Dijkstra，SPFA在处理极限数据的时候会退化。
code：
void SPFA(int s) {
queue<int> Q;
for(int i = 1; i <= n; i++) d[i] = INF;
d[s] = 0;
Q.push(s);
while(!Q.empty()) {
int x = Q.front(); Q.pop();
inq[x] = false;
for(int i = 1; i; i = a[i].next) {
int y = a[i].y;
if(d[y] > d[x] + a[i].val) {
d[y] = d[x] + a[i].val;
if(!inq[y]) Q.push(y);
}
}
}
}
求最长路
虽然大部分无环图都可以转化为DAG经典模型求解，但SPFA也是可以的，dijkstra好像也行（这个不太清楚）。
代码在后面例题讲。
判负环
这好像是SPFA的标志了，在差分约束有用到。
例题
虽然说这题是动态规划的例题，但也可以最长路做。
题目是这个意思：
有n（n <= 30） 种立方体，每个都有无穷个。要求选择一些立方体垒成一根尽量高的柱子（可以自行选择长宽高），使得每个立方体的底面长宽高分别严格小于它下方的立方体的底面长宽。
思路：
每个立方体说是可以用无穷次，其实最多只能用三次。然后每次输入一个立方体的时候转化为三个立方体，
O（n^2）建边，如果立方体x底面长宽 小于立方体y底面长宽就加一条y->x 的边，权值为立方体x的高度。
这样还不够，我们再用一个多余的节点对每一个立方体加边，权值为该立方体的高，然后跑最长路就好了。
code：（样例都没过，所以就看看原理）
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
const int MAXNC = 100, MAXN = 1000;
const long long INF = 1e11 + 9;
struct point {
int x, y, z;
point() {}
point(int x, int y, int z) {
this->x = x;
this->y = y;
this->z = z;
}
}a[MAXNC];
struct edge{
int y, next, val;
edge() {}
edge(int y, int next, int val) {
this->y = y;
this->next = next;
this->val = val;
}
}e[MAXN];
int n, kase, ans, cnt;
int head[MAXNC];
long long
d[MAXNC];
bool inq[MAXNC];
bool judge(point x, point y) {
if(x.x > y.x && x.y > y.y) return true;
else if(x.y > y.x && x.x > y.y) return true;
else return false;
}
void add_edge(int x,int y,int val) {
e[++cnt] = edge(y, head[x], val);
head[x] = cnt;
return;
}
void SPFA(int s) {
queue<int> Q;
for(int i = 1; i <= 3 * n; i++) d[i] = 0;
// d[s] = 0;
Q.push(s);
while(!Q.empty()) {
int x = Q.front(); Q.pop();
inq[x] = false;
for(int i = head[x]; i; i = e[i].next) {
// printf("%d %d %d\n", x, e[i].y, e[i].val);
int y = e[i].y;
if(d[y] < d[x] + e[i].val) {
d[y] = d[x] + e[i].val;
if(!inq[y]) Q.push(y), inq[y] = true;
}
}
}
}
int main() {
scanf("%d",&n);
while(n) {
for(int i = 1; i < 3 *n; i += 3) {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
a[i] = point(x, y, z);
a[i + 1] = point(y, z, x);
a[i + 2] = point(z, x, y);
}
memset(head,0,sizeof(head));
cnt = 0;
for(int i = 1; i<= 3 * n; i++)
for(int j = 1; j <= 3 *n; j++)
if(i != j && judge(a[i], a[j]))
add_edge(i, j, a[j].z);
for(int i = 1; i <= 3 * n; i++)
add_edge(3 * n + 1, i, a[i].z);
SPFA(3 * n + 1);
ans = 0;
for(int i = 1; i<= 3 * n; i++) if(d[i] > ans) ans = d[i];
// for(int i = 1; i <= 3 * n; i++) printf("%d ",-d[i]);
// for(int i = 1; i <= 3 * n + 1; i++)
// for(int j = head[i]; j; j = e[j].next)
// printf("x=%d y=%d val=%d\n", i, e[j].y, e[j].val);
printf("Case %d: maximum height = %d\n", ++kase, ans);
scanf("%d",&n);
}
return 0;
}
下面是AC代码（题解最长路）：
#include<iostream>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
int n, mx;
int dis[100], visited[100];
queue<int> q;
struct cubes{
int x;
int y;
int z;
}cube[100];
struct Node{
int from;
int to;
int weight;
};
vector<Node> edges[100];
void spfa(){
while(!q.empty()){
int top=q.front(); q.pop();
visited[top]=false;
for(int i=0;i<edges[top].size();i++){
int t=edges[top][i].to;
if(dis[t]<edges[top][i].weight+dis[top]){
dis[t]=edges[top][i].weight+dis[top];
if(!visited[t]){
visited[t]=true;
q.push(t);
}
}
}
}
}
int main(){
cin >> n;
int c=0;
while(n!=0){
c++;
memset(cube, 0, sizeof(cube));
memset(dis, 0, sizeof(dis));
for(int i=0;i<100;i++){
edges[i].clear();
}
for(int i=1;i<=3*n;i+=3){
int x, y, z;
cin >> x >> y >> z;
cube[i].x=x; cube[i].y=y; cube[i].z=z;
cube[i+1].x=y; cube[i+1].y=z; cube[i+1].z=x;
cube[i+2].x=z; cube[i+2].y=x; cube[i+2].z=y;
}
for(int i=1;i<=n*3;i++){
for(int j=1;j<=n*3;j++){
if((cube[i].x<cube[j].x && cube[i].y<cube[j].y) || (cube[i].x<cube[j].y && cube[i].y<cube[j].x)){
// cout << j << " to " << i << ": " << cube[j].x << " " << cube[i].x << " " << cube[j].y << " " << cube[i].y << endl;
Node a;
a.from=j;
a.to=i;
a.weight=cube[i].z;
edges[j].push_back(a);
}
}
}
for(int i=1;i<=3*n;i++){
dis[i]=cube[i].z;
q.push(i);
visited[i]=true;
}
spfa();
int mx=0;
for(int i=1;i<=n*3;i++){
if(dis[i]>mx) mx=dis[i];
}
cout << "Case " << c << ": maximum hight = ";
cout << mx << endl;
cin >> n;
}
return 0;
}
（写的还没我的好看）
2.P3385 【模板】负环
都说是模板了，下面是代码：
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int MAXNC=2000+100,MAXN=500000,INF=0x7fffffff;
int d[MAXNC],head[MAXNC],num[MAXNC];
bool inq[MAXNC];
int n,m,cnt;
struct edge {
int y,next,val;
edge() {}
edge(int y,int next,int val) {
this->y=y;
this->next=next;
this->val=val;
}
}a[MAXN];
void add_edge (int x,int y,int val);
bool SPFA(int s) {
queue<int> Q;
for(int i = 1;i <= n;i++) d[i] = INF,num[i]=0,inq[i]=0;
Q.push(s);
d[s] = 0; inq[s] = 1;
while(!Q.empty()) {
int x = Q.front(); Q.pop();
inq[x] = 0;
if(num[x] >= n) return true;
for(int i = head[x]; i; i = a[i].next) {
int y=a[i].y;
if(d[y]> d[x] + a[i].val) {
d[y] = d[x] + a[i].val;
if(!inq[y]) {
Q.push(y);
inq[y]=1;
if(++num[y]>=n) return true;
}
}
}
}
return false;
}
int main(){
int t;
scanf("%d",&t);
while(t--){
scanf("%d %d", &n, &m);
cnt=0;
memset(head,0,sizeof(head));
for(int i = 1;i <= m; i++) {
int x,y,val;
scanf("%d %d %d", &x, &y, &val);
if(val<0) add_edge(x,y,val);
else add_edge(x,y,val),add_edge(y,x,val);
}
if(SPFA(1)) printf("YE5\n");
else printf("N0\n");
}
return 0;
}
void add_edge(int x,int y,int val){
a[++cnt] = edge(y, head[x], val);
head[x] = cnt;
return ;
}
请仔细看看“YE5” 和 “N0”
最短路的例题大都可以用Dijkstra做，而且效率更高，这就不再说最短路的题了。
总结
SPFA求最短路的时间复杂度是o（KE）的，k是一个常数，一般为2，但处理特殊数据时会“退化”。（Dijkstra不会）；
SPFA可以处理负边权而且可以找负环（Dijkstra不行）；
SPFA的算法原理（渐进法）使得它作用范围更广（BFS）；
而且代码量要比Dijkstra要少很多。
一个非常优秀的算法。
补充
链式前向星记录路径
我没不知道说什么,就是再求最短路的时候记录当前松弛的边，这必然是在最短路径上的边，然后一点一点摸到起点上去就好。
SPFA版：
#include<cstdio>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
const int MAXNC = 1e5 + 100, MAXN = 1e6, INF = 0x3f3f3f3f;
struct edge {
int x, y, next, val, cnt; // 为了记录路径竟然多塞了这么多东西
edge() {}
edge(int x, int y, int next, int val, int cnt) {
this->x = x;
this->y = y;
this->next = next;
this->val = val;
this->cnt = cnt;
}
}a[MAXN];
vector<int> Path[MAXNC];
int head[MAXNC], d[MAXNC], p[MAXNC],inq[MAXNC];
int n, m, cnt, S;
void read();
void add_edge(int x, int y, int val);
void SPFA(int s);
void Get_Shortest_Paths(int s, vector<int>* Path);
void ask_print();
int main() {
scanf("%d %d %d", &n, &m, &S);
read();
Get_Shortest_Paths(S, Path); //真是毒瘤
ask_print();
return 0;
}
void read() {
for(int i = 1; i <= m; i++) {
int x, y, val;
scanf("%d %d %d", &x, &y, &val);
add_edge(x, y, val);
}
return;
}
void add_edge(int x, int y, int val) {
a[++cnt] = edge(x, y, head[x], val, cnt);
head[x] = cnt;
return;
}
void SPFA(int s) {
queue<int> Q;
for(int i = 1; i <= n; i++) d[i] = INF;
d[s] = 0;
Q.push(s);
while(!Q.empty()) {
int x = Q.front(); Q.pop();
inq[x] = false;
for(int i = head[x]; i; i = a[i].next) {
int y = a[i].y;
if(d[y] > d[x] + a[i].val) {
d[y] = d[x] + a[i].val;
p[y] = a[i].cnt;
if(!inq[y] && (inq[y] = true)) Q.push(y);
}
}
}
return;
}
void Get_Shortest_Paths(int s, vector<int>* Path) {
SPFA(s);
for(int i = 1; i <= n; i++) {
Path[i].clear();
int t = i;
Path[i].push_back(t);
while(s != t) {
Path[i].push_back(a[p[t]].x);
t = a[p[t]].x;
}
reverse(Path[i].begin(),Path[i].end());
}
return;
}
void ask_print() {
int x;
scanf("%d", &x);
for(vector<int> :: iterator it = Path[x].begin(); it != Path[x].end(); it++)
printf("%d ", *it);
// printf("\nd[%d] = %d",x,d[x]);
printf("\n\n");
return;
}
/*
4 6 1
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4
4
*/
Dijkstra版：
#include<cstdio>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
const int MAXNC = 1e6, MAXN = 1e4, INF = 0x3f3f3f3f;
struct heapnode {
int x, s;
heapnode() {}
heapnode(int x,int s) {
this->x = x;
this->s = s;
}
bool operator < (const heapnode &rhs) const {
return s > rhs.s;
}
};
struct edge{
int x, y, next, val, cnt;
edge() {}
edge(int x, int y, int next, int val, int cnt) {
this->x = x;
this->y = y;
this->next = next;
this->val = val;
this->cnt = cnt;
}
}a[MAXNC];
vector<int> Path[MAXN];
int d[MAXN], vis[MAXN], head[MAXN], p[MAXN];
int n, m, cnt, S;
void read();
void add_edge(int x, int y, int val);
void Dijkstra(int s);
void Get_shortest_Path(int s);
void ask_print();
int main() {
scanf("%d %d %d", &n, &m, &S);
read();
Get_shortest_Path(S);
ask_print();
return 0;
}
void read() {
for(int i = 1; i <= m; i++) {
int x, y, val;
scanf("%d %d %d", &x, &y, &val);
add_edge(x, y, val);
}
}
void add_edge(int x, int y, int val) {
a[++cnt] = edge(x, y, head[x], val, cnt);
head[x] = cnt;
}
void Get_shortest_Path(int s) {
Dijkstra(s);
for(int i = 1; i <= n; i++) {
Path[i].clear();
int t = i;
Path[i].push_back(i);
while(t != s) {
Path[i].push_back(a[p[t]].x);
t = a[p[t]].x;
}
reverse(Path[i].begin(), Path[i].end());
}
return;
}
void Dijkstra(int s) {
priority_queue<heapnode> Q;
for(int i = 1; i <= n; i++) d[i] = INF;
d[s] = 0;
Q.push(heapnode(s,0));
while(!Q.empty()) {
heapnode tmp = Q.top(); Q.pop();
int x = tmp.x;
if(vis[x]) continue;
vis[x] = true;
for(int i = head[x]; i; i = a[i].next) {
int y = a[i].y;
if(d[y] > d[x] + a[i].val) {
d[y] = d[x] + a[i].val;
p[y] = a[i].cnt;
Q.push(heapnode(y,d[y]));
}
}
}
return;
}
void ask_print() {
int x;
scanf("%d", &x);
for(vector<int> :: iterator it = Path[x].begin();it != Path[x].end(); it++)
printf("%d ", *it);
printf("\n\n");
}
路径追踪例题
两个题，我也都没做过。
1，UVA11374 Airport Express(省选难度，加油)
在IokhIok**h市中，机场快线是市民从市内去机场的首选交通工具。机场快线分为经济线和商业线两种，线路、速度和价钱都不同。你有一张商业线车票，可以坐一站商业线，而其他时候只能乘坐经济线。假设换乘时间忽略不计，你的任务是找一条去机场最快的线路。
输入格式：
输入包含多组数据。每组数据第一行为33个整数N, SN,S和E(2 \leq N \leq 500, 1 \leq S, E \leq 100)E(2≤N≤500,1≤S,E≤100)，即机场快线中的车站总数，起点和终点（即机场所在站）编号。下一行包含一个整数M(1 \leq M \leq 1000)M(1≤M≤1000)，即经济线的路段条数。以下MM行每行3个整数X, Y, Z(1 \leq X, Y \leq N, 1 \leq Z \leq 100)X,Y,Z(1≤X,Y≤N,1≤Z≤100)，表示可以乘坐经济线在车站XX和车站YY之间往返，其中单程需要ZZ分钟。下一行为商业线的路段条数K(1 \leq K \leq 1000)K(1≤K≤1000)，以下KK行是这些路段的描述，格式同经济线。所有路段都是双向的，但有可能必须使用商业车票才能到达机场。保证最优解唯一。
输出格式：
对于每组数据，输出33行。第一行按访问顺序给出经过的各个车站（包括起点和终点），第二行是换乘商业线的车站编号（如果没有商业线车票，输出Ticket Not Used），第三行是总时间。
2，P2176 [USACO14FEB]路障Roadblock(这道题个人认为比上面的难，但难度却是提高的)
题目描述
每天早晨，FJ从家中穿过农场走到牛棚。农场由 N 块农田组成，农田通过 M 条双向道路连接，每条路有一定长度。FJ 的房子在 1 号田，牛棚在 N 号田。没有两块田被多条道路连接，以适当的路径顺序总是能在农场任意一对田间行走。当FJ从一块田走到另一块时，总是以总路长最短的道路顺序来走。
FJ 的牛呢，总是不安好心，决定干扰他每天早晨的计划。它们在 M 条路的某一条上安放一叠稻草堆，使这条路的长度加倍。牛希望选择一条路干扰使得FJ 从家到牛棚的路长增加最多。它们请你设计并告诉它们最大增量是多少。
输入输出格式
输入格式：
第 1 行：两个整数 N, M。
第 2 到 M+1 行：第 i+1 行包含三个整数 A_i, B_i, L_i，A_i 和 B_i 表示道路 i 连接的田的编号，L_i 表示路长。
输出格式：
第 1 行：一个整数，表示通过使某条路加倍而得到的最大增量。
输入输出样例
输入样例#1：
5 7
2 1 5
1 3 1
3 2 8
3 5 7
3 4 3
2 4 7
4 5 2输出样例#1：
2
SPFA(Shortest Path Faster Algorithm)的更多相关文章
- Proof for Floyd-Warshall's Shortest Path Derivation Algorithm Also Demonstrates the Hierarchical Path Construction Process
(THIS BLOG WAS ORIGINALLY WRTITTEN IN CHINESE WITH LINK: http://www.cnblogs.com/waytofall/p/3732920. ...
- ACM学习历程—HDU4725 The Shortest Path in Nya Graph（SPFA && 优先队列）
Description This is a very easy problem, your task is just calculate el camino mas corto en un grafi ...
- Hdu 4725 The Shortest Path in Nya Graph (spfa)
题目链接: Hdu 4725 The Shortest Path in Nya Graph 题目描述: 有n个点,m条边,每经过路i需要wi元.并且每一个点都有自己所在的层.一个点都乡里的层需要花费c ...
- ZOJ 2760 - How Many Shortest Path - [spfa最短路][最大流建图]
人老了就比较懒,故意挑了到看起来很和蔼的题目做,然后套个spfa和dinic的模板WA了5发,人老了,可能不适合这种刺激的竞技运动了…… 题目链接:http://acm.zju.edu.cn/onli ...
- Method for finding shortest path to destination in traffic network using Dijkstra algorithm or Floyd-warshall algorithm
A method is presented for finding a shortest path from a starting place to a destination place in a ...
- 【ZOJ2760】How Many Shortest Path
How Many Shortest Path 标签: 网络流 描述 Given a weighted directed graph, we define the shortest path as th ...
- HDU4889 Scary Path Finding Algorithm
Fackyyj loves the challenge phase in TwosigmaCrap(TC). One day, he meet a task asking him to find sh ...
- 程序员的算法课（19）-常用的图算法：最短路径(Shortest Path)
版权声明:本文为博主原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接和本声明. 本文链接:https://blog.csdn.net/m0_37609579/article/de ...
- zoj 2760 How Many Shortest Path 最大流
题目链接:http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=1760 Given a weighted directed graph ...
随机推荐
- 代理模式(Proxy)C++实现
代理模式 尽管Decorator的实现部分与代理相似,但Decorator的目的不一样.Decorator为对象添加一个或多个功能,而代理则控制对对象的访问. 意图: 为其他对象提供一种代理以控制对这 ...
- 关于React-native的介绍以及环境搭建
React-Native介绍(后面内容的RN就是指react-native) 由facebook公司推出的,基于react,能开发原生app 原理: 1. 利用react框架写好js代码 2. 利用p ...
- Android学习——利用RecyclerView编写聊天界面
1.待会儿会用到RecyclerView,首先在app/build.gradle(注意有两个build.gradle,选择app下的那个)当中添加依赖库,如下: dependencies { comp ...
- 谈谈c++中继承中的虚函数
c++继承中的虚函数 c++是一种面向对象的编程语言的一个很明显的体现就是对继承机制的支持,c++中继承分很多种,按不同的分类有不同分类方法,比如可以按照基类的个数分为多继承和单继承,可以按照访问 ...
- 【Five-Minute Share】“请先了解所使用的工具 ，磨刀不误砍柴工”
数据是应用系统的血液,没有数据的系统应用价值是非常有限的.经过多年的观察发现,身边很多的程序开发人员在开发应用系统的时候,都是按照标准SQL语法及应用方法去进行数据库设计,并进行应用开发的,没有任何的 ...
- sql修改字段值
update dfw_USER_ACCOUNTS set USER_INTEGRAL="20" where USER_INTEGRAL="17"
- Apache Http Client 4 上传多个文件 （示例代码可在 github 上找到）
转自:http://www.baeldung.com/httpclient-multipart-upload Multipart Upload with HttpClient 4 1. Overvie ...
- 关于linux系统的sendmail使用中的问题与解决
系统环境是ubuntu16.04 安装 sudo apt-get install sendmail 检查运行情况 sudo service sendmail status 结果如下,表示正在运行 ● ...
- 「Poetize4」创世纪
在tyvj上怀疑爆栈了.....或许一定是我写挂了.以后调吧... UPD:bzoj上过了... 题解:https://blog.csdn.net/popoqqq/article/details/39 ...
- 中国电信线CTF线下选拨writeup
[盟军密码|30分] 二战时盟军截获德军一段密码,密文为:0000011000000000101010110111000011000111100011110001001100111000111001( ...