C++博客-Yuan-随笔分类-图论

Spoj 1479 最小直径生成树

_Yuan — Wed, 20 Jul 2011 17:12:00 GMT

摘要: Amber <> 半径只需计算这些相邻点Li，即为最优值了在这之前，需要去除掉一些点，只保留最外层的那些，才能有上面那样子交点 Code highlighting produced by Actipro CodeHighlighter (freeware)http://w... 阅读全文

_Yuan 2011-07-21 01:12 发表评论

hdu 3832 枚举分叉点

_Yuan — Fri, 15 Jul 2011 12:07:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->/**//* n<=200个点的无向图，要求前3个点需要连接在一起，求最多能删除的其余点连在一起，想到生... 阅读全文

_Yuan 2011-07-15 20:07 发表评论

CF76A 排序降维加边成环删最大边利用MST性质

_Yuan — Thu, 05 May 2011 15:36:00 GMT

摘要: /**//* n<=200个点，m<=50000条边的无向图，每条边有值(gi,si) 如果某条边满足gi<=g && si <= s，则这条边可通过现要构造出一个(g,s)，使得... 阅读全文

_Yuan 2011-05-05 23:36 发表评论

poj 3694 LCA活用割边

_Yuan — Fri, 30 Apr 2010 04:16:00 GMT

/*
    不错一道题
    题意：给出一幅图，里面有桥，给出Q个操作，    每个操作会添加一条边，问每次操作后图中桥的个数
    每次求桥会太慢
    考虑一下dfs树，树边肯定是桥，然后每连上x,y，就会形成一个环，这个环内的边就全部都不是割边
    所以只要找到x,y的lca，把这个路径上的桥标记为否即可
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int MAXN=100010;

inline int min(int a,int b){return a<b?a:b;}
inline int max(int a,int b){return a>b?a:b;}

struct Node{
    int v,next;
}nodes[MAXN*10];

int G[MAXN];
int level[MAXN],low[MAXN];
int vi[MAXN],fa[MAXN];
int cut[MAXN],isBridge[MAXN];
int alloc,n,m,bridgeNum;

void add(int a,int b){
    alloc++;
    nodes[alloc].v=b,nodes[alloc].next=G[a];
    G[a]=alloc;
}

void dfs(int u,int dep){
    vi[u]=1;
    level[u]=low[u]=dep;
    bool flag=true;
    //if(u!=1)cut[u]++;
    for(int son=G[u];son;son=nodes[son].next){
        int v=nodes[son].v;
        if(v==fa[u]&&flag){
            flag=false;
            continue;
        }
        if(vi[v]==1)
            low[u]=min(low[u],level[v]);
        else if(vi[v]==0){
            fa[v]=u;
            dfs(v,dep+1);
            low[u]=min(low[u],low[v]);
            //if(low[v]>=level[u])cut[u]++;
            if(low[v]>level[u]){//bridge
                isBridge[v]=1;
                bridgeNum++;
            }
        }
    }
    vi[u]=2;
}
void lca(int x,int y){
    if(level[x]<level[y])swap(x,y);
    while(level[x]>level[y]){
        if(isBridge[x]){
            bridgeNum--;
            isBridge[x]=0;
        }
        x=fa[x];
    }
    while(x!=y){
        if(isBridge[x]){bridgeNum--;isBridge[x]=0;}
        if(isBridge[y]){bridgeNum--;isBridge[y]=0;}
        x=fa[x];y=fa[y];
    }
}
int main(){
    //freopen("in","r",stdin);
    int a,b,t=1;
    while(scanf("%d%d",&n,&m),n){
        alloc=0;
        memset(G+1,0,sizeof(int)*n);
        while(m--){
            scanf("%d%d",&a,&b);
            add(a,b);
            add(b,a);
        }
        memset(vi,0,sizeof(vi));
        memset(isBridge,0,sizeof(isBridge));
        bridgeNum=0;
        fa[1]=1;
        dfs(1,0);
        printf("Case %d:\n",t++);
        scanf("%d",&m);
        while(m--){
            scanf("%d%d",&a,&b);
            lca(a,b);
            printf("%d\n",bridgeNum);
        }
        puts("");
    }
    return 0;
}

_Yuan 2010-04-30 12:16 发表评论

hdu 2242 双连通缩点成树 tree dp

_Yuan — Thu, 29 Apr 2010 14:22:00 GMT

摘要: /**//* 题意：给出一些点，有值，给出一些边，然后求去掉一条边后将分成连通的两部分，且两部分的差值最小先将双连通分量缩点，成为一棵树，树边即桥，然后再递归一下就行注意，这里的重边当成两条路！！！ &nbs... 阅读全文

_Yuan 2010-04-29 22:22 发表评论

hdu 2767 最小加边使有向图变为强连通

_Yuan — Tue, 27 Apr 2010 14:37:00 GMT

/*
    求最小加边使有向图变为强连通
    先缩点，然后计算各个强连通分量的入度为0的个数，出度为0的个数
    1) SCC=1, 不需添边
    2) 添max( incnt, outcnt )
                    贪心策略，汇基向点基连边，再添边的连接剩下的点基/汇基即可

*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;

const int MAXN=20010;

int n,m;
vector<int>G[2][MAXN];
int ID[MAXN],SCC,flag;
int order[MAXN],cnt;
int in[MAXN],out[MAXN];

void dfs(int u){
    ID[u]=SCC;
    for(int i=0;i<G[flag][u].size();i++){
        int v=G[flag][u][i];
        if(!ID[v])dfs(v);
    }
    if(flag)order[++cnt]=u;
}

int main(){
    int T,a,b;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++){
            G[0][i].clear();
            G[1][i].clear();
        }
        while(m--){
            scanf("%d%d",&a,&b);
            G[0][a].push_back(b);
            G[1][b].push_back(a);
        }
        flag=SCC=1;
        cnt=0;
        memset(ID,0,sizeof(ID));
        for(int i=1;i<=n;i++)
            if(!ID[i])dfs(i);
        flag=SCC=0;
        memset(ID,0,sizeof(ID));
        for(int i=cnt;i;i--){//注意是order[i]
            if(ID[order[i]])continue;
            SCC++;
            dfs(order[i]);
        }
        if(SCC==1){puts("0");continue;}
        memset(out,0,sizeof(out));
        memset(in,0,sizeof(in));
        for(int i=1;i<=n;i++)
            for(int j=0;j<G[0][i].size();j++){
                int v=G[0][i][j];
                if(ID[i]!=ID[v]){
                    in[ID[v]]++;
                    out[ID[i]]++;
                }
            }
        int incnt=0,outcnt=0;
        for(int i=1;i<=SCC;i++){
            if(in[i]==0)incnt++;
            if(out[i]==0)outcnt++;
        }
        printf("%d\n",max(incnt,outcnt));
    }
    return 0;
}

_Yuan 2010-04-27 22:37 发表评论

Poj 3463 最短路次短路的路径条数之和

_Yuan — Mon, 19 Apr 2010 05:59:00 GMT

/*
    求s到t的最短路与次短路（这里要求只比最短路多1）的条数之和

    联想到最小，次小的一种更新关系：
    if(x<最小)更新最小，次小
    else if(==最小)更新方法数
    else if(x<次小)更新次小
    else if(x==次小)更新方法数

    同时记录s到u最短，次短路及方法数
    用一个堆每次取最小的，更新完后再入堆
    还是那个原理，第一次遇到的就是最优的，然后vi标记为真
    方法数注意是加法原理，不是乘法
    \
    -- u -- v  所以是加法原理
    /
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

const int MAXN=1010;
const int INF=1000000000;

bool vi[MAXN][2];
int dist[MAXN][2],cnt[MAXN][2];//0 表示最短路 1表示次短路
int G[MAXN];
int n,m,alloc;

struct Node{
    int v,w,next;
}nodes[MAXN*10];

struct Pos{
    int v,flag;
    Pos(int vv,int f){v=vv,flag=f;}
    bool operator<(const Pos &p)const {
        return dist[v][flag]>dist[p.v][p.flag];
    }
};

void add(int a,int b,int c){
    alloc++;
    nodes[alloc].v=b,nodes[alloc].w=c,nodes[alloc].next=G[a];
    G[a]=alloc;
}

int dij(int s,int t){
    memset(vi,0,sizeof(vi));
    memset(cnt,0,sizeof(cnt));
    for(int i=1;i<=n;i++)
        dist[i][0]=dist[i][1]=INF;
    priority_queue<Pos>Q;
    Q.push(Pos(s,0));
    dist[s][0]=0;cnt[s][0]=1;
    while(!Q.empty()){
        Pos top=Q.top();Q.pop();
        int u=top.v,flag=top.flag;
        if(vi[u][flag])continue;
        vi[u][flag]=1;
        for(int son=G[u];son;son=nodes[son].next){
            int v=nodes[son].v,w=dist[u][flag]+nodes[son].w;
            if(w<dist[v][0]){
                if(dist[v][0]!=INF){
                    dist[v][1]=dist[v][0];
                    cnt[v][1]=cnt[v][0];
                    Q.push(Pos(v,1));
                }
                dist[v][0]=w;
                cnt[v][0]=cnt[u][flag];
                Q.push(Pos(v,0));
            }
            else if(w==dist[v][0])cnt[v][0]+=cnt[u][flag];
            else if(w<dist[v][1]){
                dist[v][1]=w;
                cnt[v][1]=cnt[u][flag];
                Q.push(Pos(v,1));
            }
            else if(w==dist[v][1])cnt[v][1]+=cnt[u][flag];
        }
    }

    int ans=cnt[t][0];
    if(dist[t][0]==dist[t][1]-1)ans+=cnt[t][1];
    return ans;
}
int main(){
    int T,a,b,c;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        memset(G,0,sizeof(G));
        alloc=0;
        while(m--){
            scanf("%d%d%d",&a,&b,&c);
            add(a,b,c);
        }
        scanf("%d%d",&a,&b);
        printf("%d\n",dij(a,b));
    }
    return 0;
}

_Yuan 2010-04-19 13:59 发表评论

hdu 2444 判断是否二分图再最大匹配

_Yuan — Sat, 17 Apr 2010 15:31:00 GMT

/*
    Your task is to divide the students into two groups so that any two students in the same group don't know each other.
    也即问是否存在二分图，通过判断是否有奇数长度回路即可 dfs一下
    当然，允许多棵森林
    then arrange them into double rooms 相识的同一间房，即求最大匹配
*/
#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;

const int MAXN=210;

struct Node{
    int v,next;
}nodes[MAXN*MAXN];

int G[MAXN];
int link[MAXN];
int n,m,alloc;
int vi[MAXN];

void add(int a,int b){
    alloc++;
    nodes[alloc].v=b,nodes[alloc].next=G[a];
    G[a]=alloc;
}
bool dfs(int u,int p){
    for(int son=G[u];son;son=nodes[son].next){
        int v=nodes[son].v;
        if(v==p)continue;
        if(vi[v]!=-1){
            if(vi[v]==vi[u])return false;//层次相差为偶数，即偶数回路
            continue;
        }
        vi[v]=1-vi[u];
        if(!dfs(v,u))return false;
    }
    return true;
}
bool find(int u){
    for(int son=G[u];son;son=nodes[son].next){
        int v=nodes[son].v;
        if(vi[v])continue;
        vi[v]=1;
        if(!link[v]||find(link[v])){
            link[v]=u;
            return true;
        }
    }
    return false;
}
int main(){
    //freopen("in","r",stdin);
    int a,b;
    while(~scanf("%d%d",&n,&m)){
        alloc=0;
        memset(G,0,sizeof(G));
        for(int i=0;i<m;i++){
            scanf("%d%d",&a,&b);
            add(a,b);add(b,a);
        }
        memset(vi,-1,sizeof(vi));
        bool flag=false;
        for(int i=1;i<=n;i++)
            if(vi[i]==-1){
                vi[i]=1;
                if(!dfs(i,i)){
                    flag=true;
                    break;
                }
            }
        if(flag){printf("No\n");continue;}
        int ans=0;
        memset(link,0,sizeof(link));
        for(int i=1;i<=n;i++){
            memset(vi,0,sizeof(vi));
            ans+=find(i);
        }
        printf("%d\n",ans/2);
    }
    return 0;
}

_Yuan 2010-04-17 23:31 发表评论

Poj 3686 拆点二分图最佳匹配

_Yuan — Tue, 13 Apr 2010 17:05:00 GMT

/*
    题意：有N个工件要在M个机器上加工，有一个N*M的矩阵描述其加工时间。
    同一时间内每个机器只能加工一个工件，问加工完所有工件后，使得平均加工时间最小。

    将工件作为二分图中X部的点，总共N个。
    将每个机器拆成N个点作为二分图中Y部的点，总共N*M个。
    第J个机器的第P个点代表，使用机器 J进行倒数第P次加工。
    假设我们按顺序在J机器上工件I1,I2,I3..IK个工件，则总共需要花费I1*K+I2*(K- 1)+I3*(K-3)++IK。
    所以我们对于X中每个点I，Y中每个点（J,P），连接一条A[I,J]*P权值的边。
    接下来进行二分图最佳匹配即可。
*/
#include<cstdio>
#include<cstring>

const int MAXN=55;
const int INF=1000000000;

int n,m;
int g[MAXN][MAXN*MAXN];
int data[MAXN][MAXN];
int lx[MAXN],ly[MAXN*MAXN];//可行顶标
int cx[MAXN],cy[MAXN*MAXN];//匹配边集
bool sx[MAXN],sy[MAXN*MAXN];

bool path(int u){//扩展二分图判断是否存在由行元素u出发的可增广路径
    sx[u]=1;
    for(int v=1;v<=m;v++){
        if(g[u][v]==lx[u]+ly[v]&&!sy[v]){
            sy[v]=1;
            if(cy[v]==0||path(cy[v])){
                cx[u]=v;cy[v]=u;
                return true;
            }
        }
    }
    return false;
}
int KM(){
    memset(ly,0,sizeof(ly));
    memset(cx,0,sizeof(cx));
    memset(cy,0,sizeof(cy));
    for(int i=1;i<=n;i++){
        lx[i]=-INF;
        for(int j=1;j<=m;j++)
            if(lx[i]<g[i][j])lx[i]=g[i][j];
    }
    for(int u=1;u<=n;u++){
        memset(sx,0,sizeof(sx));
        memset(sy,0,sizeof(sy));
        while(!path(u)){
            int Min=INF;
            for(int i=1;i<=n;i++){
                if(!sx[i])continue;
                for(int j=1;j<=m;j++)
                    if(!sy[j]&&lx[i]+ly[j]-g[i][j]<Min)
                        Min=lx[i]+ly[j]-g[i][j];
            }
            //调整顶标，二分图撤去该元素
            for(int i=1;i<=n;i++)
                if(sx[i]){lx[i]-=Min;sx[i]=false;}
            for(int i=1;i<=m;i++)
                if(sy[i]){ly[i]+=Min;sy[i]=false;}
        }
    }
    int ans=0;
    for(int i=1;i<=n;i++)
        ans+=g[i][cx[i]];
    return ans;
}
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
                scanf("%d",&data[i][j]);
        //build
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
                for(int k=1;k<=n;k++)
                    g[i][(j-1)*n+k]=-data[i][j]*k;//花费
        m=n*m;
        double ans=-1.0*KM()/n;
        printf("%.6f\n",ans);
    }
    return 0;
}

_Yuan 2010-04-14 01:05 发表评论

Poj 2112 二分多重匹配

_Yuan — Mon, 12 Apr 2010 02:54:00 GMT

/*
    1y，有点意外
    对应匈牙利算法看，不同的是右边的点可匹配多个
*/
#include<cstdio>
#include<cstring>

const int MAXN=1005;

struct Node{
    int v,next;
}nodes[MAXN*MAXN];

int n,m;
int G[MAXN];
int alloc,N;
bool vi[MAXN];
int link[MAXN][MAXN];

void add(int a,int b){
    alloc++;
    nodes[alloc].v=b,nodes[alloc].next=G[a];
    G[a]=alloc;
}
bool find(int u){
    for(int son=G[u];son!=-1;son=nodes[son].next){
        int v=nodes[son].v;
        //v对应多个匹配
        if(vi[v])continue;
        vi[v]=1;
        if(link[v][0]<N){
            link[v][++link[v][0]]=u;
            return true;
        }
        for(int i=1;i<=link[v][0];i++)
            if(find(link[v][i])){
                link[v][i]=u;
                return true;
            }
    }
    return false;
}
bool chk(){
    int ans=0;
    for(int i=0;i<m;i++)link[i][0]=0;
    for(int i=0;i<n;i++){
        memset(vi,0,sizeof(vi));
        if(!find(i))return false;
    }
    return true;
}
int main(){
    char str[20],ch;
    while(scanf("%d%d",&n,&m),n){
        memset(G,-1,sizeof(G));
        alloc=0;
        for(int i=0;i<n;i++){
            scanf("%s",str);
            while(1){
                while(ch=getchar(),ch==' ');
                int tmp=ch-'0';
                while(ch=getchar(),ch<='9'&&ch>='0')tmp=10*tmp+ch-'0';
                add(i,tmp);
                if(ch=='\n'||ch==EOF)break;
            }
        }
        int low=0,high=n+1;
        while(high-low>1){
            int mid=(high+low)>>1;
            N=mid;
            if(chk())high=mid;
            else low=mid;
        }
        printf("%d\n",high);
    }
    return 0;
}

_Yuan 2010-04-12 10:54 发表评论

C++博客-Yuan-随笔分类-图论

Spoj 1479 最小直径生成树

hdu 3832 枚举分叉点

CF76A 排序降维 加边成环删最大边 利用MST性质

poj 3694 LCA活用 割边