Improve算法

#include <bits/stdc++.h>
#define maxn 100000
#define maxm 2000000
#define eps 1e-7
#define INF 1<<30
using namespace std;

struct Edge{
    int u;          //u表示边的起点
    int v;          //v表示边的终点
    int next;       //next表示下一条边编号
    double w;       //w表示边的容量
}edge[maxm];        //网络流建模时用到的边

int e;                  //边的计数器
int S;                  //超级源点
int T;                  //超级汇点
int first[maxn];        //图邻接表头结点
int d[maxn];            //层次图距离标记
int work[maxn];         //dinic优化
int q[maxn];            //bfs队列
int deg[maxn];          //每个点的度数
set<int>::iterator iter;
set<int> A;             //A集合中的点
vector<int> G[maxn];    //原始图上的边

bool f1[maxn];          //残量网络与S连通的点集
bool f2[maxn];          //残量网络与T连通的点集

int n;      //图上的点数
int m;      //图上的边数
int k;      //A集合中点的数量
int vol_a;  //A集合的容量vol(A)
int cut_a;  //跨越A和V-A的边数
double f;       //f(A)=vol(A)/vol(V-A)
double alpha;   //与网络流边容量相关的参数α
/*图的初始化*/
void init(){
    e = 0;
    memset(first,-1,sizeof(first));
}

/*加边*/
void add_edge(int a,int b,double c){
    //printf("add_edge:from %d to %d,val = %.4f\n",a,b,c);
    edge[e].u = a;
    edge[e].v = b;
    edge[e].next = first[a];
    edge[e].w = c;
    first[a] = e++;

    edge[e].u = b;
    edge[e].v = a;
    edge[e].next = first[b];
    edge[e].w = 0;
    first[b] = e++;
}

/*bfs构造层次图*/
int bfs(){
    int rear = 0;
    memset(d,-1,sizeof(d));
    d[S] = 0;q[rear++] = S;
    for(int i = 0;i < rear;i++){
        for(int j = first[q[i]];j != -1;j = edge[j].next){
            int to = edge[j].v;
            double val = edge[j].w;
            if(abs(val) > eps && d[to] == -1){
                d[to] = d[q[i]]+1;
                q[rear++] = to;
                if(to == T) return 1;
            }
        }
    }
    return 0;
}

/*dfs计算阻塞流*/
double dfs(int cur,double a){
    if(cur == T)    return a;
    for(int &i = work[cur];i != -1;i = edge[i].next){
        int to = edge[i].v;
        double val = edge[i].w;
        if(abs(val) > eps && d[to] == d[cur]+1){
            if(double t = dfs(to,min(a,val))){
                edge[i].w -= t;edge[i^1].w += t;
                return t;
            }
        }
    }
    return 0;
}

void dfs1(int u){
    f1[u] = 1;
    for(int i = first[u];i != -1;i = edge[i].next){
        int to = edge[i].v;
        double val = edge[i].w;
        if(!f1[to] && val > eps)    dfs1(to);
    }
}

void dfs2(int u){
    f2[u] = 1;
    for(int i = first[u];i != -1;i = edge[i].next){
        int to = edge[i].v;
        double val = edge[i^1].w;
        if(!f2[to] && val > eps)    dfs2(to);
    }
}

void build(double alpha){
    init();
    for(int i = 1;i <= n;i++){
        if(A.find(i) != A.end()){
            add_edge(S,i,deg[i]);
        }else{
            add_edge(i,T,f*deg[i]);
        }
    }
    for(int u = 1;u <= n;u++){
        for(int i = 0;i < G[u].size();i++){
            int v = G[u][i];
            add_edge(u,v,1.0/alpha);
            add_edge(v,u,1.0/alpha);
        }
    }
}

double dinic(){
    double ans = 0,t;
    while(bfs()){
        memcpy(work,first,sizeof(first));
        while(true){
            t = dfs(S,INF);
            if(t < eps) break;
            ans += t;
        }
    }
    return ans;
}

double min_cut(){
    memset(f1,0,sizeof(f1));
    memset(f2,0,sizeof(f2));
    dfs1(S);
    dfs2(T);

    int cnt = 0;    //表示跨越集合的边数

    //printf("min_cut edge:\n");
    for(int i = 0;i < e;i += 2){
        if(f1[edge[i].u] && f2[edge[i].v] && edge[i].w < eps){
            //printf("from %d to %d\n",edge[i].u,edge[i].v);
            if(edge[i].u == S || edge[i].u == T)    continue;
            if(edge[i].v == S || edge[i].v == T)    continue;
            cnt++;
        }
    }

    int vol1 = 0,vol2 = 0;
    for(int i = S+1;i < T;i++){
        if(f1[i]){
            vol1 += deg[i];
            //printf("flag1:%d\n",i);
        }
        if(f2[i]){
            if(A.find(i) != A.end())  vol2 += deg[i];
        }
    }

    printf("cnt = %d,vol1 = %d,total-vol1 = %d\n",cnt,vol1,2*m-vol1);
    if(cnt == 0)   return 0;
    double conductance = cnt*1.0/min(vol1,2*m-vol1);
    printf("conductance = %.5f\n",conductance);

    double QAS = cnt*1.0/(vol1-f*vol2);
    return QAS;
}

int main()
{
    freopen("wing_nodal.txt","r",stdin);
    freopen("output.txt","w",stdout);
    scanf("%d%d%d",&n,&m,&k);
    S = 0,T = n+1;
    vol_a = cut_a = 0;
    for(int i = 0;i < m;i++){
        int a,b;
        scanf("%d%d",&a,&b);
        G[a].push_back(b);
        G[b].push_back(a);
        deg[a]++;deg[b]++;
    }
    for(int i = 0;i < k;i++){
        int a;
        scanf("%d",&a);
        A.insert(a);
        vol_a += deg[a];
    }
    for(iter = A.begin();iter != A.end();iter++){
        int u = *iter;
        for(int i = 0;i < G[u].size();i++){
            int v = G[u][i];
            if(A.find(v) != A.end())    continue;
            cut_a++;
        }
    }
    f = vol_a*1.0/(2*m-vol_a);
    alpha = cut_a*1.0/vol_a;
    double best_alpha = alpha;
    printf("init:cut_a = %d,vol_a = %d\n",cut_a,vol_a);
    printf("before algorithm,conductance = %.5f\n",alpha);
    clock_t time_begin,time_end;
    time_begin = clock();
    while(true){
        build(alpha);
        double maxflow = dinic();
        double QAS = min_cut();
        printf("maxflow = %.5f\n",maxflow);
        printf("QAS = %.5f\n",QAS);
        if(abs(QAS) < eps){
            break;
        }else{
            best_alpha = alpha;
        }
        if(QAS < alpha){
            alpha = QAS;
        }else{
            break;
        }
    }
    puts("------------------result-----------------");
    printf("best alpha = %.5f\n",best_alpha);
    build(best_alpha);
    dinic();
    min_cut();

    time_end = clock();
    double delta = (double)(time_end - time_begin) / CLOCKS_PER_SEC;
    printf("\n,delta_time = %.5f s\n",delta);
    return 0;
}