暑假集训-二分图,网络流,2-SAT

　　匈牙利算法DFS

　　

bool dfs(int u){
    for(int i = ; i <= n; i++){
        if(a[u][i] && !visit[i]){
            visit[i] = true;
            if(match[i] == - || dfs(match[i])){
                match[i] = u;
            }
            return true;
        }
    }
    return false;
}

最优匹配KM算法

#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <set>
#define LL long long
#define eps 1e-8
#define INF 0x3f3f3f3f
#define OPEN_FILE
#define MAXM 1005
#define MAXN 205
using namespace std;
int n, m;
char s[MAXN][MAXM];
int a[MAXN][MAXN], match[MAXN], fx[MAXN], fy[MAXN];
bool x[MAXN], y[MAXN];

bool dfs(int u){
    x[u] = true;
    for(int i = ; i <= n; i++){
        if(y[i]) continue;
        int p = fx[u] + fy[i] - a[u][i];
        if(p == ){
            y[i] = true;
            if(match[i] == - || dfs(match[i])){
                match[i] = u;
                return true;
            }
        }else{
            m = min(m, p);
        }
    }
    return false;
}
void KM(){
    int i,j;
    memset(fx,,sizeof(fx));
    memset(fy,,sizeof(fy));
    memset(match,-,sizeof(match));
    for(int i = ; i <= n; i++){
        for(int j = ; j <= n; j++){
            if(a[i][j] > fx[i]){
                fx[i] = a[i][j];
            }
        }
    }
    for(int i = ; i <= n; i++){
        while(true){
            memset(x, , sizeof(x));
            memset(y, , sizeof(y));
            m = INF;
            if(dfs(i)) break;
            for(int j = ; j <= n; j++){
                if(x[j]) fx[j] -= m;
                if(y[j]) fy[j] += m;
            }
        }
    }
}
int main()
{
#ifdef OPEN_FILE
    //freopen("inD.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
#endif // OPEN_FILE
    while(~scanf("%d", &n)){
        memset(a, , sizeof(a));
        for(int i = ; i <= n; i++){
            scanf("%s", s[i]);
        }
        for(int i = ; i <= n; i++){
            int p = strlen(s[i]);
            for(int j = ; j <= n; j++){
                if(i == j) continue;
                int q = strlen(s[j]) - ;
                int cnt = ;
                while(cnt < p && q >=  && s[i][cnt] == s[j][q]){
                    cnt++;
                    q--;
                }
                a[i][j] = cnt;
            }
        }
        KM();
        int ans = ;
        for(int i = ; i <= n; i++){
            ans += a[match[i]][i];
        }
        printf("%d\n", ans);
    }
}

2-SAT

这里面的add_clause的作用式是针对 x=xval or y=yval的时候加边,建不同的图要加不同的边,这里要注意下!!

比如还有一个经典的题目 HDU1824, 建图的时候要格外注意.对于前面队内关系来说是相互的,必须要有一个留下,但是对于队友关系来说却不是相互的,之存在A留B走而不存在A走B必须留的情况,所以加边的里面要写成单向的.

struct TwoSAT{
    int n;
    vector<int> G[MAXN*];
    bool mark[MAXN*];
    int S[MAXN*], c;

    bool dfs(int x){
        if(mark[x^]) return false;
        if(mark[x]) return true;
        mark[x] = true;
        S[c++] = x;
        for(int i = ; i < G[x].size(); i++){
            if(!dfs(G[x][i])) return false;
        }
        return true;
    }

    void init(int n){
        this->n = n;
        for(int i = ; i < n * ; i++){
            G[i].clear();
        }
        memset(mark, , sizeof(mark));
    }

    void add_clause(int x, int xval, int y, int yval){
        x = x *  + xval;
        y = y *  + yval;
        G[x^].push_back(y);
        G[y^].push_back(x);
    }

    bool solve(){
        for(int i = ; i < n * ; i += ){
            if(!mark[i] && !mark[i + ]){
                c = ;
                if(!dfs(i)){
                    while(c > ){
                        mark[S[--c]] = false;
                    }
                    if(!dfs(i + )){
                        return false;
                    }
                }
            }
        }
        return true;
    }
};

Max-Flow(Dinic)

struct Dinic{
    int n, m, i, s, t;
    Edge e;
    vector<Edge> edges;
    vector<int> G[MAXN];
    int d[MAXN], cur[MAXN];
    bool vis[MAXN];
    void init(int n){
        this->n = n;
        for (i = ; i <= n; i++){
            G[i].clear();
        }
        edges.clear();
    }
    void AddEdge(int from, int to, int cap){
        edges.push_back(Edge{ from, to, cap,  });
        edges.push_back(Edge{ to, from, ,  });
        m = edges.size();
        G[from].push_back(m - );
        G[to].push_back(m - );
    }
    bool BFS(){
        memset(vis, , sizeof(vis));
        queue<int> Q;
        Q.push(s);
        d[s] = ;
        vis[s] = ;
        while (!Q.empty()){
            int x = Q.front();
            Q.pop();
            for (i = ; i < G[x].size(); i++){
                Edge& e = edges[G[x][i]];
                if (!vis[e.to] && e.cap > e.flow){
                    vis[e.to] = true;
                    d[e.to] = d[x] + ;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }
    int DFS(int x, int a){
        if (x == t || a == ) return a;
        int flow = , f;
        for (int& i = cur[x]; i < G[x].size(); i++){
            Edge& e = edges[G[x][i]];
            if (d[x] +  == d[e.to] && (f = DFS(e.to, min(a, e.cap - e.flow))) > ){
                e.flow += f;
                edges[G[x][i] ^ ].flow -= f;
                flow += f;
                a -= f;
                if (a == ) break;
            }
        }
        return flow;
    }
    int MaxFlow(int s, int t, int need){
        int flow = ;
        this->s = s;
        this->t = t;
        while (BFS()){
            memset(cur, , sizeof(cur));
            flow += DFS(s, INF);
            if (flow > need) return flow;
        }
        return flow;
    }
    bool checkFull(int s){
        for (int i = ; i < G[s].size(); i++){
            if (edges[G[s][i]].flow != edges[G[s][i]].cap){
                return false;
            }
        }
        return  true;
    }
};

MCMF

struct Edge{
    int u,v,c,cost,next;
}edge[E];
int head[V],cnt;

void init(){
    cnt=;
    memset(head,-,sizeof(head));
}
void addedge(int u,int v,int c,int cost)
{
    edge[cnt].u=u;edge[cnt].v=v;edge[cnt].cost=cost;
    edge[cnt].c=c;edge[cnt].next=head[u];head[u]=cnt++;

    edge[cnt].u=v;edge[cnt].v=u;edge[cnt].cost=-cost;
    edge[cnt].c=;edge[cnt].next=head[v];head[v]=cnt++;
}

bool spfa(int begin,int end){
    int u,v;
    queue<int> q;
    for(int i=;i<=end+;i++){
        pre[i]=-;
        vis[i]=;
        dist[i]=inf;
    }
    vis[begin]=;
    dist[begin]=;
    q.push(begin);
    while(!q.empty()){
        u=q.front();
        q.pop();
        vis[u]=;
        for(int i=head[u];i!=-;i=edge[i].next){
            if(edge[i].c>){
                v=edge[i].v;
                if(dist[v]>dist[u]+edge[i].cost){
                    dist[v]=dist[u]+edge[i].cost;
                    pre[v]=i;
                    if(!vis[v]){
                        vis[v]=true;
                        q.push(v);
                    }
                }
            }
        }
    }
    return dist[end]!=inf;
}

int MCMF(int begin,int end){
    int ans=,flow;
    int flow_sum=;
    while(spfa(begin,end)){
        flow=inf;
        for(int i=pre[end];i!=-;i=pre[edge[i].u])
            if(edge[i].c<flow)
                flow=edge[i].c;
        for(int i=pre[end];i!=-;i=pre[edge[i].u]){
            edge[i].c-=flow;
            edge[i^].c+=flow;
        }
        ans+=dist[end];
        flow_sum += flow;
    }
    //cout << flow_sum << endl;
    return ans;
}