2017.7.11 图论测试

---

　　我先用费用流的方法去跑spfa，然后完美T掉6个点。

　　就说正解吧，正解是跑两次spfa，然后就可以找出最短路覆盖的边(详细过程请看代码rebuild())。然后建图跑最大流

Code

#include <iostream>
#include <cstdio>
#include <ctime>
#include <cmath>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <fstream>
#include <sstream>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <vector>
#include <stack>
#ifndef WIN32
#define Auto "%lld"
#else
#define Auto "%I64d"
#endif
using namespace std;
typedef bool boolean;
const signed int inf = (signed)((1u << 31) - 1);
const double eps = 1e-6;
const int binary_limit = 128;
#define smin(a, b) a = min(a, b)
#define smax(a, b) a = max(a, b)
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
template<typename T>
inline boolean readInteger(T& u){
    char x;
    int aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-' && x != -1);
    if(x == -1) {
        ungetc(x, stdin);    
        return false;
    }
    if(x == '-'){
        x = getchar();
        aFlag = -1;
    }
    for(u = x - '0'; isdigit((x = getchar())); u = (u << 1) + (u << 3) + x - '0');
    ungetc(x, stdin);
    u *= aFlag;
    return true;
}

typedef class Edge {
    public:
        int end;
        int next;
        int flow;
        int cap;
        int lvl;
        Edge(int end = 0, int next = -1, int flow = 0, int cap = 0, int lvl = 0):end(end), next(next), flow(flow), cap(cap), lvl(lvl) {    }
}Edge;

typedef class MapManager {
    public:
        int ce;
        vector<Edge> edge;
        int* h;
        
        MapManager():ce(0), h(NULL) {        }
        MapManager(int nodes):ce(0) {
            h = new int[(const int)(nodes + 1)];
            memset(h, -1, sizeof(int) * (nodes + 1));
        }
        
        inline void addEdge(int from, int end, int flow, int cap, int lvl) {
            edge.push_back(Edge(end, h[from], flow, cap, lvl));
            h[from] = ce++;
        }
        
        inline void addDoubleEdge(int from, int end, int cap, int lvl) {
            if(cap == 0)    return;
            addEdge(from, end, 0, cap, lvl);
            addEdge(end, from, cap, cap, lvl);
        }
        
        Edge& operator [] (int pos) {
            return edge[pos];
        }
}MapManager;
#define m_begin(g, i) (g).h[(i)]
#define m_endpos -1

#define LL long long

int n, m;
int s, t;
MapManager g;

inline void init() {
    readInteger(n);
    readInteger(m);
    g = MapManager(n + 1);
    s = 1, t = n;
    for(int i = 1, a, b, c; i <= m; i++) {
        readInteger(a);
        readInteger(b);
        readInteger(c);
        g.addDoubleEdge(a, b, 1, c);
    }
}

queue<int> que;
boolean* vis;
LL *f;
LL *f1;
inline void init_spfa() {
    vis = new boolean[t + 1];
    f = new LL[t + 1];
    f1 = new LL[t + 1];
}

inline void spfa(int s, int t, LL* &f2, boolean sign) {
    memset(vis, false, sizeof(boolean) * (n + 1));
    memset(f2, 0x7f, sizeof(long long) * (n + 1));
    f2[s] = 0;
    que.push(s);
    while(!que.empty()) {
        int e = que.front();
        que.pop();
        vis[e] = false;
        for(int i = m_begin(g, e); i != m_endpos; i = g[i].next) {
            int& eu = g[i].end;
            if(g[i].flow ^ sign)    continue;
            if(f2[eu] > f2[e] + g[i].lvl) {
                f2[eu] = f2[e] + g[i].lvl;
                if(!vis[eu] && eu != t) {
                    vis[eu] = true;
                    que.push(eu);
                } 
            }
        }
    }
}

boolean* onpath;
MapManager rg;
inline void rebuild() {
    rg = MapManager(t);
    onpath = new boolean[(t + 1)];
    memset(onpath, false, sizeof(boolean) * (t + 1));
    for(int i = 1; i <= n; i++)
        if(f[i] + f1[i] == f[t])
            onpath[i] = true;
    for(int i = s; i <= t; i++) {
        if(!onpath[i])    continue;
        for(int j = m_begin(g, i); j != m_endpos; j = g[j].next) {
            int& e = g[j].end;
            if(onpath[e] && g[j].flow == 0 && f[i] + g[j].lvl == f[e])
                rg.addDoubleEdge(i, e, 1, 0); //,printf("%d->%d
", i, e);
        }
    }
}

int *divs;
inline boolean bfs() {
    memset(divs, -1, sizeof(int) * (t + 1));
    que.push(s);
    divs[s] = 0;
    while(!que.empty()) {
        int e = que.front();
        que.pop();
        for(int i = m_begin(rg, e); i != m_endpos; i = rg[i].next) {
            int& eu = rg[i].end;
            if(divs[eu] != -1 || rg[i].cap == rg[i].flow)    continue;
            divs[eu] = divs[e] + 1;
            que.push(eu);
        }
    }
    return divs[t] != -1;
}

int *cur;
int blockedflow(int node, int minf) {
    if(node == t || minf == 0)    return minf;
    int f, flow = 0;
    for(int& i = cur[node]; i != m_endpos; i = rg[i].next) {
        int& e = rg[i].end;
        if(divs[e] == divs[node] + 1 && (f = blockedflow(e, min(minf, rg[i].cap - rg[i].flow))) > 0) {
            rg[i].flow += f;
            rg[i ^ 1].flow -= f;
            flow += f;
            minf -= f;
            if(minf == 0)    return flow;
        }
    }
    return flow;
}

inline int dinic() {
    divs = new int[(t + 1)];
    cur = new int[(t + 1)];
    int maxflow = 0;
    while(bfs()) {
        for(int i = s; i <= t; i++)
            cur[i] = m_begin(rg, i);
        maxflow += blockedflow(s, inf);
    }
    return maxflow;
}

inline void solve() {
    printf("%d", dinic());
}

int main() {
    freopen("change.in", "r", stdin);
    freopen("change.out", "w", stdout);
    init();
    init_spfa();
    spfa(s, t, f, false);
    spfa(t, s, f1, true);
    rebuild();
    solve();
    return 0;
}

---

---

　　二分答案,然后奇、偶数分开分别连源点和汇点，两者加起来是素数就加一条边。特殊处理1，只保留一个。

Code

#include <iostream>
#include <cstdio>
#include <ctime>
#include <cmath>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <fstream>
#include <sstream>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <vector>
#include <stack>
#ifndef WIN32
#define Auto "%lld"
#else
#define Auto "%I64d"
#endif
using namespace std;
typedef bool boolean;
const signed int inf = (signed)((1u << 31) - 1);
const double eps = 1e-6;
const int binary_limit = 128;
#define smin(a, b) a = min(a, b)
#define smax(a, b) a = max(a, b)
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
template<typename T>
inline boolean readInteger(T& u){
    char x;
    int aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-' && x != -1);
    if(x == -1) {
        ungetc(x, stdin);    
        return false;
    }
    if(x == '-'){
        x = getchar();
        aFlag = -1;
    }
    for(u = x - '0'; isdigit((x = getchar())); u = (u << 1) + (u << 3) + x - '0');
    ungetc(x, stdin);
    u *= aFlag;
    return true;
}

typedef class Edge {
    public:
        int end;
        int next;
        int flow;
        int cap;
        int lvl;
        Edge(int end = 0, int next = -1, int flow = 0, int cap = 0, int lvl = 0):end(end), next(next), flow(flow), cap(cap), lvl(lvl) {    }
}Edge;

typedef class MapManager {
    public:
        int ce;
        vector<Edge> edge;
        int* h;
        
        MapManager():ce(0), h(NULL) {        }
        MapManager(int nodes):ce(0) {
            h = new int[(const int)(nodes + 1)];
            memset(h, -1, sizeof(int) * (nodes + 1));
        }
        
        inline void addEdge(int from, int end, int flow, int cap, int lvl) {
            edge.push_back(Edge(end, h[from], flow, cap, lvl));
            h[from] = ce++;
        }
        
        inline void addDoubleEdge(int from, int end, int cap, int lvl) {
            if(cap == 0)    return;
//            printf("%d -> %d (with the capt %d)
", from, end, cap);
            addEdge(from, end, 0, cap, lvl);
            addEdge(end, from, cap, cap, lvl);
        }
        
        Edge& operator [] (int pos) {
            return edge[pos];
        }
        
        inline void clear() {
            edge.clear();
            delete[] h;
        }
}MapManager;
#define m_begin(g, i) (g).h[(i)]
#define m_endpos -1

int n, m;
int s, t;
int *fs, *ts, *ls;

inline void init() {
    readInteger(n);
    readInteger(m);
    s = 0, t = n + 1;
    fs = new int[(n + 1)];
    ts = new int[(n + 1)];
    ls = new int[(n + 1)];
    int sum = 0;
    for(int i = 1; i <= n; i++) {
        readInteger(fs[i]);
        readInteger(ts[i]);
        readInteger(ls[i]);
        sum += fs[i];
    }
    if(sum < m) {
        puts("-1");
        exit(0);
    }
}

int num = 0;
const int limit = 2e7;
int prime[1270608];
boolean *vis;
inline void Euler() {
    vis = new boolean[limit + 1];
    memset(vis, false, sizeof(boolean) * (limit + 1));
    for(int i = 2; i <= limit; i++) {
        if(!vis[i])    prime[num++] = i;
        for(int j = 0; j < num; j++) {
            int x = i * 1LL * prime[j];
            if(x > limit)    break;
            vis[x] = true;
            if((i % prime[j]) == 0)    break;
        }
    }
}

inline void init_map(MapManager& g, int mid, int& sum) {
    g = MapManager(t);
    int maxonef = 0, maxid = -1;
    for(int i = 1; i <= n; i++)
        if(ls[i] <= mid && ts[i] == 1 && fs[i] > maxonef)
            maxonef = fs[i], maxid = i;
    for(int i = 1; i <= n; i++) {
        if(((ts[i] == 1 && i == maxid) || (ts[i] != 1 && (ts[i] & 1) == 1)) && ls[i] <= mid)
            g.addDoubleEdge(s, i, fs[i], ls[i]), sum += fs[i];
        else if((ts[i] & 1) == 0 && ls[i] <= mid)
            g.addDoubleEdge(i, t, fs[i], ls[i]), sum += fs[i];
    }
    for(int i = 1; i <= n; i++) {
        if(!(ts[i] & 1))    continue;
        for(int j = 1; j <= n; j++) {
            if(!vis[ts[i] + ts[j]]) {
                g.addDoubleEdge(i, j, inf, 0);
            }
        }
    }
}

int* dep;
queue<int> que;
MapManager g;
inline boolean bfs(int mid) {
    memset(dep, -1, sizeof(int) * (t + 1));
    dep[s] = 0;
    que.push(s);
    while(!que.empty()) {
        int e = que.front();
        que.pop();
        for(int i = m_begin(g, e); i != m_endpos; i = g[i].next) {
            int& eu = g[i].end;
            if(dep[eu] != -1)    continue;
            if(g[i].lvl > mid)    continue;
            if(g[i].cap == g[i].flow)    continue;
            dep[eu] = dep[e] + 1;
            que.push(eu);
        }
    }
    return dep[t] != -1;
}

int* cur;
int blockedflow(int node, int minf, int mid) {
    if(node == t || minf == 0)    return minf;
//    cout << node << endl;
    int f, flow = 0;
    for(int& i = cur[node]; i != m_endpos; i = g[i].next) {
        int& e = g[i].end;
        if(g[i].lvl <= mid && dep[e] == dep[node] + 1 && (f = blockedflow(e, min(minf, g[i].cap - g[i].flow), mid)) > 0) {
            g[i].flow += f;
            g[i ^ 1].flow -= f;
            flow += f;
            minf -= f;
            if(minf == 0)    return flow;
        }
    }
    return flow;
}

inline void init_dinic() {
    dep = new int[(t + 1)];
    cur = new int[(t + 1)];
}

int dinic(int mid) {
    int sum = 0, maxflow = 0;
    init_map(g, mid, sum);
    while(bfs(mid)) {
        for(int i = s; i <= t; i++)
            cur[i] = m_begin(g, i);
        maxflow += blockedflow(s, inf, mid);
    }
    g.clear();
//    cout << maxflow << endl;
    return sum - maxflow;
}

inline void solve() {
    int l = 1, r = (1e9) + 1;
    while(l <= r) {
        int mid = (l + r) >> 1;
        if(dinic(mid) >= m)    r = mid - 1;
        else l = mid + 1;
    }
    if(r == (1e9) + 1)    puts("-1");
    else printf("%d
", r + 1);
}

int main() {
    freopen("card.in", "r", stdin);
    freopen("card.out", "w", stdout);
    Euler();
    init();
    init_dinic();
    solve();
    return 0;
}

---

---

　　先Tarjan弄一发，然后开始spfa，转移的时候判一下起点和终点是否在同一强连通分量内。

Code

#include <iostream>
#include <cstdio>
#include <ctime>
#include <cmath>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <fstream>
#include <sstream>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <vector>
#include <stack>
#ifndef WIN32
#define Auto "%lld"
#else
#define Auto "%I64d"
#endif
using namespace std;
typedef bool boolean;
const signed int inf = (signed)((1u << 31) - 1);
const signed long long llf = (signed long long)((1ull << 61) - 1);
const double eps = 1e-6;
const int binary_limit = 128;
#define smin(a, b) a = min(a, b)
#define smax(a, b) a = max(a, b)
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
template<typename T>
inline boolean readInteger(T& u){
    char x;
    int aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-' && x != -1);
    if(x == -1) {
        ungetc(x, stdin);    
        return false;
    }
    if(x == '-'){
        x = getchar();
        aFlag = -1;
    }
    for(u = x - '0'; isdigit((x = getchar())); u = (u << 1) + (u << 3) + x - '0');
    ungetc(x, stdin);
    u *= aFlag;
    return true;
}

///map template starts
typedef class Edge{
    public:
        int end;
        int next;
        int w;
        Edge(const int end = 0, const int next = 0, const int w = 0):end(end), next(next), w(w){}
}Edge;

typedef class MapManager{
    public:
        int ce;
        int *h;
        Edge *edge;
        MapManager(){}
        MapManager(int points, int limit):ce(0){
            h = new int[(const int)(points + 1)];
            edge = new Edge[(const int)(limit + 1)];
            memset(h, 0, sizeof(int) * (points + 1));
        }
        inline void addEdge(int from, int end, int w){
            edge[++ce] = Edge(end, h[from], w);
            h[from] = ce;
        }
        inline void addDoubleEdge(int from, int end, int w){
            addEdge(from, end, w);
            addEdge(end, from, w);
        }
        Edge& operator [] (int pos) {
            return edge[pos];
        }
}MapManager;
#define m_begin(g, i) (g).h[(i)]
///map template ends

#define LL long long

typedef class Data {
    public:
        LL mag;
        LL dis;
        
        Data(LL mag = llf, LL dis = llf):mag(mag), dis(dis) {        }

        boolean operator < (Data b) const {
            if(mag != b.mag)    return mag < b.mag;
            return dis < b.dis;
        }
        
        Data operator + (Data b) {
            return Data(mag + b.mag, dis + b.dis);
        }
}Data;

int n, m;
MapManager g;
MapManager rg;

inline void init() {
    readInteger(n);
    readInteger(m);
    g = MapManager(n, m);
    rg = MapManager(n, m);
    for(int i = 1, a, b, c; i <= m; i++) {
        readInteger(a);
        readInteger(b);
        readInteger(c);
        g.addEdge(a, b, c);
        rg.addEdge(b, a, c);
    }
}

int cnt = 0, scc = 0;
int* visitID;
int* exitID;
boolean* visited;
boolean* instack;
stack<int> s;
int *belong;
inline void init_tarjan() {
    int an = n + 1;
    visitID = new int[(an)];
    exitID = new int[(an)];
    visited = new boolean[(an)];
    instack = new boolean[(an)];
    belong = new int[(an)];
    memset(visited, false, sizeof(boolean) * an);
    memset(instack, false, sizeof(boolean) * an);
    memset(belong, 0, sizeof(int) * an);
}

void tarjan(int node) {
    visitID[node] = exitID[node] = cnt++;
    visited[node] = instack[node] = true;
    s.push(node);
    
    for(int i = m_begin(g, node); i; i = g[i].next) {
        int& e = g[i].end;
        if(!visited[e]) {
            tarjan(e);
            smin(exitID[node], exitID[e]);
        } else if(instack[e]) {
            smin(exitID[node], visitID[e]);
        }
    }
    
    if(visitID[node] == exitID[node]) {
        int now = -1;
        scc++;
        while(now != node) {
            now = s.top();
            s.pop();
            instack[now] = false;
            belong[now] = scc;
        }
    }
}

deque<int> que;
Data *f;
boolean *vis;
inline void spfa(int s) {
    f = new Data[n + 1];
    vis = new boolean[n + 1];
    memset(vis, false, sizeof(boolean) * (n + 1));
    que.push_front(s);
    f[s] = Data(0, 0);
    while(!que.empty()) {
        int e = que.front();
        que.pop_front();
        vis[e] = false;
        for(int i = m_begin(rg, e); i; i = rg[i].next) {
            int& eu = rg[i].end;
            Data w((belong[e] == belong[eu]) ? (1) : (0), rg[i].w);
            if(f[e] + w < f[eu]) {
                f[eu] = f[e] + w;
                if(!vis[eu]) {
                    vis[eu] = true;
                    if(!que.empty() && f[eu] < f[que.front()])
                        que.push_front(eu);
                    else
                        que.push_back(eu);
                }
            }
        }
    }
}

inline void solve() {
    for(int i = 2; i <= n; i++) {
        if(f[i].mag == llf)
            puts("-1");
        else 
            printf(Auto" "Auto"
", f[i].mag, f[i].dis);
    }
}

int main() {
    freopen("festival.in", "r", stdin);
    freopen("festival.out", "w", stdout);
    init();
    init_tarjan();
    for(int i = 1; i <= n; i++)
        if(!visited[i])
            tarjan(i);
    spfa(1);
    solve();
    return 0;
}