C++博客-ArcTan-文章分类-ACM-图论

POJ 2762-Tarjan + 拓扑排序

wangs — Wed, 17 Oct 2012 09:22:00 GMT

题意：给定无向图，判断是否任何两点（x,y），可以从x到y或者从y到x.

The son can either go from x to y, or from y to x.

思路：Tarjan缩点后，充要条件是，成一条链。拓扑排序求判断之。

#include<stdio.h>
#include<string.h>
#include<math.h>
#define maxn 1010
#define maxm 60600

struct edge{
    int v;
    int next;
}edges[maxm];
int last[maxn];
int edge_cnt;
void add_edge(int u,int v)
{
    edges[edge_cnt].v = v;
    edges[edge_cnt].next = last[u];
    last[u] = edge_cnt++;
    return ;
}

int dfn[maxn],low[maxn];
int color[maxn];
bool instack[maxn];
int st[maxn],top;
int cnt,scnt;

int n,m;
int N;
int mat[maxn][maxn];
int topo[maxn];
int dg[maxn];
int path[maxn];

int min(int x,int y)
{
    return x<y?x:y;
}
void tarjan(int u)
{
    dfn[u]=low[u]=cnt++;
    st[++top]=u;
    instack[u]=1;
    for (int j=last[u];j!=-1;j=edges[j].next)
    {
        int v = edges[j].v;
        if (dfn[v]==-1)
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if (instack[v])
            low[u]=min(low[u],low[v]);
    }

    if (low[u]==dfn[u])
    {
        scnt++;
        int x;
        do
        {
            x=st[top--];
            instack[x]=0;
            color[x]=scnt;
        }while (x!=u);
    }
    return ;
}
void solve()
{
    cnt = 0;
    scnt = 0;
    top = 0;
    memset(dfn,-1,sizeof(dfn)); //初始这里居然错了。
    memset(instack,0,sizeof(instack));
    for (int i=1;i<=n;i++)
        if (dfn[i]==-1)
            tarjan(i);
    return ;
}

void init()
{
    memset(last,-1,sizeof(last));
    edge_cnt = 0;
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        add_edge(u,v);
    }
    return ;
}
void work()
{
    solve();
    N = scnt;//求出的强连通数
    memset(mat,0,sizeof(mat));
    for (int i=1;i<=n;i++)
    {
        for (int j=last[i];j!=-1;j=edges[j].next)
        {
            int v = edges[j].v;
            mat[color[i]][color[v]]=1;
        }
    }
    return ;
}

bool topsort()
{
    memset(dg,0,sizeof(dg));
    for (int i=1;i<=N;i++)
        for (int j=1;j<=N;j++)
            if (i!=j)//注意自己到自己不可。当是就在这里WA了！
                dg[i] += mat[j][i];
    for (int k=1;k<=N;k++)
    {
        int i=1;
        while (dg[i]>0 && i<=n) i++;
        if (i>n)
            return 0;
        dg[i]=-1;
        for (int j=1;j<=N;j++)
            dg[j]-=mat[i][j];
        path[k]=i;
    }
    return 1;
}
int main()
{
    int cas;
    scanf("%d",&cas);
    while (cas--)
    {
        init();
        work();
        bool flag = 1;
        topsort();
        for (int i=1;i<N;i++)
        {
            if (!mat[path[i]][path[i+1]])
            {
                flag = 0;
                break;
            }
        }
        if (flag)
            puts("Yes");
        else
            puts("No");
    }
    return 0;
}

/*

3 3
1 2
2 3
3 1

8 11
1 2
2 3
2 5
2 6
3 5
4 3
5 2
5 4
6 7
6 8
7 6

*/

wangs 2012-10-17 17:22 发表评论

Tarjan算法求图的强连通模版

wangs — Tue, 16 Oct 2012 04:14:00 GMT

边的储存

struct edge
{
    int v;
    int next;
} edges[maxn*maxn];
int last[maxn];
int tot;

void add(int u,int v)
{
    edges[tot].v = v;
    edges[tot].next = last[u];
    last[u] = tot++;
    return ;
}

int dfn[maxn],low[maxn]; //时间戳最早能回溯到的祖先位置。
int color[maxn]; //所属连通分量编号
bool instack[maxn];
int st[maxn],top; //模拟栈
int cnt,scnt; //时间和连通分量计数

Tarjan算法部分：

void tarjan(int u)
{
    int x;
    dfn[u]=low[u]=cnt++;
    st[++top]=u;
    instack[u]=1;
    for (int j=last[u];j!=-1;j=edges[j].next)
    {
        int v = edges[j].v;
        if (dfn[v]==-1)
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(instack[v]) low[u]=min(low[u],dfn[v]);
    }

    if (dfn[u]==low[u]) //以u为根节点的树形成一个连通分量
    {
        do
        {
            x=st[top--];
            instack[x]=0;
            color[x]=scnt;
        }
        while (x!=u);
        scnt++;
    }
    return ;
}

solv()函数部分：

void solve()
{
    cnt=0;
    scnt=0;
    top=0;
    memset(dfn,-1,sizeof(dfn));
    memset(instack,0,sizeof(instack));
    for(int i=0; i<n*2; i++)
        if (dfn[i]==-1)
        {
            tarjan(i);
        }
    return ;
}

2—SAT中判断是否形成自环check()

bool check()
{
    for (int i=0; i<n; i++)
        if (color[i]==color[i+n])
            return 0;
    return 1;
}

求出连通分量的解。待定。

wangs 2012-10-16 12:14 发表评论

连通图--顶点连通度的求解 POJ 1966

wangs — Thu, 19 Jul 2012 09:09:00 GMT

有向图G中求顶点连通度：
      1、独立轨P(A,B)
      2、Menger定理：无向图G的顶点连通度
               k(G)=V|G|-1 G是完全图，min ! in E（P（A，B））else
      3、用最大流法求P（A，B）。
      4、建图：e=(u,v)分成e'=(u'',v')和e''=(u',v'');e'=e''=inf。


得好好研究研究这些图论的原理，搞明白。《图论》这本书，讲得不行啊！！！！还是得好好学习《算法导论》

最大流，好要好好学！

10485949

wangsouc

1966

Accepted

248K

16MS

C++

1967B

2012-07-19 17:00:20

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<algorithm>
#define maxn 105
#define inf 105
#define min(x,y) (x
#define max(x,y) (x>y?x:y)
using namespace std;
int map[maxn][maxn];
int N,M;
int max_flow(int num,int map[][maxn],int source,int sink)
{
    int que[maxn],head,tail;
    int pre[maxn],min_flow[maxn];

    int flow[maxn][maxn];
    int ans=0;
    memset(flow,0,sizeof(flow));
    while (1)
    {
        head=0;tail=1;
        que[1]=source;
        memset(pre,-1,sizeof(pre));
        min_flow[source]=inf;
        pre[source]=-2;
        while (head<tail)
        {
            int temp=que[++head];
            for (int i=0;i<num;i++)
            {
                if (pre[i]==-1 && flow[temp][i]<map[temp][i])
                {
                    que[++tail]=i;
                    pre[i]=temp;
                    min_flow[i]=min(min_flow[temp],(map[temp][i]-flow[temp][i]));
                }
            }
            if (pre[sink]!=-1)
            {
                int k=sink;
                while (pre[k]>=0)
                {
                    flow[pre[k]][k]+=min_flow[sink];
                    flow[k][pre[k]]=-flow[pre[k]][k];
                    k=pre[k];
                }
                break;
            }
        }
        if (pre[sink]==-1)
            return ans;
        else
            ans+=min_flow[sink];
    }
}
int main()
{
    while (scanf("%d%d",&N,&M)==2)
    {
        int u,v,ans;
        int i;
        memset(map,0,sizeof(map));
        for (i=0;i<N;i++)
            map[i][i+N]=1;
        for (i=0;i<M;i++)
        {
            scanf(" (%d,%d)",&u,&v);
            map[u+N][v]=map[v+N][u]=inf;
        }
        ans=inf;
        for (i=1;i<N;i++)
        {
            ans=min(ans,max_flow(N*2,map,0+N,i));   //这里没有搞明白怎么是呢？？？
        }
        if (ans==inf)
            ans=N;
        printf("%d\n",ans);
    }
    return 0;
}

图论。

wangs 2012-07-19 17:09 发表评论

tarjan算法-求无向连通图的关节点

wangs — Wed, 18 Jul 2012 13:36:00 GMT

摘要: 无向连通图的关节点： 1、朴素算法：枚举+DFS，O(N^3)。 2、Robert Tarjan的Tarjan算法。O(N^2)　　Tarjan算法是基于对图深度优先搜索的算法，每个强连通分量为搜索树中的一棵子树。搜索时，把当前搜索树中未处理的节点加入一个堆栈，回溯时可以判断栈顶到栈中的节点是否为一... 阅读全文

wangs 2012-07-18 21:36 发表评论

Havel_Hakimi定理（可图性判定）-poj1659

wangs — Sat, 07 Jul 2012 09:45:00 GMT

度序列（Degree Sequence）：把图G所有顶点的度数排成一个序列s，则称s为图G的度序列。如
             s:2，5，4，3，3，1 或者 s1:1,2,3,4,5 或者 s2:5,4,3,2,1

可图的（Graphic）：一个非负整数组成的有限序列如果是某个无向图的度序列，则称该序列是Graphic！

Havel-Hakimi定理（贪心）：
                        由非负数组成的非增序列s:d1,d2,d3....dn（n>=2,d1>=1）是Graphic，当且仅当序列
                                               s1:d2-1,d3-1,...,d(d1+1)-1,d(d1+2),....,dn 是Graphic！

应用：poj1659：

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<algorithm>
using namespace std;
struct vertex
{
    int deg;
    int index;
} ver[12];

int adj[12][12];
int n;

int cmp(vertex v1,vertex v2)
{
    return v1.deg>v2.deg;
}
int Havel_Hak()
{
    int i,j,u,v,m;
    i=1;
    while (i<n)
    {
        sort(ver+i,ver+n+1,cmp);
        m=ver[i].deg;
        u=ver[i].index;
        if (i+m>n)
            return 0;
        j=i+1;
        while (j<=i+m)
        {
            ver[j].deg--;
            if (ver[j].deg<0)
                return 0;
            v=ver[j].index;
            adj[u][v]=adj[v][u]=1;
            j++;
        }
        i++;
    }
    return 1;
}
int print(int flag)
{
    int i,j;
    if (!flag)
    {
        printf("NO\n");
        return 0;
    }
    printf("YES\n");
    for (i=1;i<=n;i++)
    {
        for (j=1;j<n;j++)
            printf("%d ",adj[i][j]);
        printf("%d\n",adj[i][j]);
    }
    return 0;
}
int main()
{
    int t,i;
    scanf("%d",&t);
    while (t--)
    {
        scanf("%d",&n);
        for (i=1;i<=n;i++)
        {
            scanf("%d",&ver[i].deg);
            ver[i].index=i;
        }
        memset(adj,0,sizeof(adj));
        print(Havel_Hak());

        if (t>0)
            printf("\n");
    }
    return 0;
}

wangs 2012-07-07 17:45 发表评论

匈牙利算法-二分图的最大匹配

wangs — Fri, 06 Jul 2012 04:29:00 GMT

二分图最大匹配的匈牙利算法：

二分图是这样一个图，它的顶点可以分类两个集合X和Y，所有的边关联在两个顶点中，恰好一个属于集合Ｘ，另一个属于集合Ｙ。

最大匹配：图中包含边数最多的匹配称为图的最大匹配。

完美匹配：如果所有点都在匹配边上，称这个最大匹配是完美匹配。

最小覆盖：最小覆盖要求用最少的点（Ｘ集合或Ｙ集合的都行）让每条边都至少和其中一个点关联。可以证明：最少的点（即覆盖数）＝最大匹配数

最小路径覆盖：

用尽量少的不相交简单路径覆盖有向无环图Ｇ的所有结点。解决此类问题可以建立一个二分图模型。把所有顶点i拆成两个：Ｘ结点集中的i和Y结点集中的i',如果有边i->j，则在二分图中引入边i->j'，设二分图最大匹配为m,则结果就是n-m。

二分图最大匹配的经典匈牙利算法是由Edmonds在1965年提出的，算法的核心就是根据一个初始匹配不停的找增广路，直到没有增广路为止。

匈牙利算法的本质实际上和基于增广路特性的最大流算法还是相似的，只需要注意两点：

（一）每个X节点都最多做一次增广路的起点；

（二）如果一个Y节点已经匹配了，那么增广路到这儿的时候唯一的路径是走到Y节点的匹配点（可以回忆最大流算法中的后向边，这个时候后向边是可以增流的）。

找增广路的时候既可以采用dfs也可以采用bfs，两者都可以保证O(nm)的复杂度，因为每找一条增广路的复杂度是O(m)，而最多增广n次，dfs在实际实现中更加简短。

算法思想：

算法的思路是不停的找增广轨, 并增加匹配的个数,增广轨顾名思义是指一条可以使匹配数变多的路径,在匹配问题中,增广轨的表现形式是一条"交错轨",也就是说这条由图的边组成的路径, 它的第一条边是目前还没有参与匹配的,第二条边参与了匹配,第三条边没有..最后一条边没有参与匹配,并且始点和终点还没有被选择过.这样交错进行,显然他有奇数条边.那么对于这样一条路径,我们可以将第一条边改为已匹配,第二条边改为未匹配...以此类推.也就是将所有的边进行"反色",容易发现这样修改以后,匹配仍然是合法的,但是匹配数增加了一对.另外,单独的一条连接两个未匹配点的边显然也是交错轨.可以证明, 当不能再找到增广轨时,就得到了一个最大匹配.这也就是匈牙利算法的思路.、

C邻接矩阵：

#include<stdio.h>
#include<string.h>
#include<math.h>
int result[105];
int state[105];
int data[105][105];
int n1,n2,m,ans;
int init()
{
    int i,x,y;
    memset(result,0,sizeof(result));
    memset(data,0,sizeof(data));
    scanf("%d%d%d",&n1,&n2,&m);
    for (i=0;i<m ;i++ )
    {
        scanf("%d%d",&x,&y);
        data[x][y]=1;
    }
    return 0;
}
int find(int x)
{
    int i;
    for (i=1;i<=n2 ;i++ )
    {
        if (data[x][i]==1 && !state[i])
        {
            state[i]=1;
            if (result[i]==0 || find(result[i]))
            {
                result[i]=x;
                return 1;
            }
        }
    }
    return 0;
}
int main()
{
    int i;
    init();
    ans=0;
    for (i=1;i<=n1 ;i++ )
    {
        memset(state,0,sizeof(state));
        if (find(i))
            ans++;
    }
    printf("%d\n",ans);
    return 0;
}

POJ_1274:

wangs 2012-07-06 12:29 发表评论