多校二总结

赛后就A了两题，第一题也做了，不过不太明白，暂时留着

第一题 Hdu 4612  

题意：给出n个点和m条边的图，存在重边，问加一条边以后，剩下的桥的数量最少为多少

没想到这样的解法：先用tarjan缩点变成一棵树，然后求树的直径，显然，用一条边将直径的两个端点连起来可以让剩余的桥数量最少。要注意会有重边，在tarjan里面要判一下。。由于会有重边所以要缩点求直径

代码：

#pragma comment(linker, "/STACK:10240000000,10240000000")//手动加桟---外挂
#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <map>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <queue>
#define LL long long
using namespace std;
#define M 300015
#define N 4000015
struct Edge
{
    int v,next;
} edge1[N],edge2[N];
int head[M],e1;
int head2[M],e2;
int belong[M],dfn[M],low[M],stc[M],top,num,st;
int n,m,ans;
int vis[M];
void init()
{
    memset(head,-1,sizeof(head));
    memset(vis,0,sizeof(vis));
    e1=0;
    top=0;
    st=num=0;
    memset(dfn,0,sizeof(dfn));
}
void addedge(int u,int v)
{
    edge1[e1].v=v;
    edge1[e1].next=head[u];
    head[u]=e1++;
    edge1[e1].v=u;
    edge1[e1].next=head[v];
    head[v]=e1++;
}
void addedge2(int u,int v)
{
    edge2[e2].v=v;
    edge2[e2].next=head2[u];
    head2[u]=e2++;
}
void tarjan(int u,int fa)
{
    dfn[u]=low[u]=++num;
    stc[++top]=u;
    int cnt=0;
    for(int i=head[u]; i!=-1; i=edge1[i].next)
    {
        int v=edge1[i].v;
        if(!dfn[v])
        {
            tarjan(v,u);
            low[u]=min(low[v],low[u]);
        }
        else if(v==fa)
        {
            if(cnt)low[u]=min(low[u],dfn[v]);
            cnt++;
        }
        else low[u]=min(low[u],dfn[v]);
    }
    if(low[u]==dfn[u])
    {
        int x;
        st++;
        do
        {
            x=stc[top--];
            belong[x]=st;
        }
        while(x!=u);
    }
}
void build()
{
    e2=0;
    memset(head2,-1,sizeof(head2));
    for(int i=1; i<=n; i++)
    {
        for(int j=head[i]; j!=-1; j=edge1[j].next)
        {
            int v=edge1[j].v;
            if(belong[i]!=belong[v])
                addedge2(belong[i],belong[v]);
        }
    }
}
int dfs(int u,int p)
{
    int max1=0,max2=0;
    for(int i=head2[u]; i!=-1; i=edge2[i].next)
    {
        int v=edge2[i].v;
        if(v==p)continue;
        int tmp=dfs(v,u)+1;
        if(max1<tmp)max2=max1,max1=tmp;
        else if(max2<tmp)max2=tmp;
    }
    ans=max(ans,max1+max2);
    return max1;
}
int main()
{
    int u,v;
    while(scanf("%d%d",&n,&m)&& n &&m)
    {
        init();
        for(int i=0; i<m; i++)
        {
            scanf("%d%d",&u,&v);
            if(v==u)continue;
            addedge(u,v);
        }
        tarjan(1,-1);
        build();
        ans=0;
        dfs(1,-1);
        printf("%d\n",st-ans-1);
    }
    return 0;
}

第九题 Hdu 4619 

题意：给定1×2的多米诺骨牌，放在平面上，可以水平放也可以竖直放，保证水平和水平的之间不重叠，竖直和竖直的不重叠，但水平和竖直的可能重叠。拿走一些牌使它们，不重叠，求平面上最多可以剩张牌

那天ran过来说是匹配问题，我就蒙了，匹配好久没写了，也忘得差不多了，幸好可以重温了一下

思路：把那些有重叠的牌之间连边构成二分图，有边相连说明至多只有一张牌能留在平面上，然后用总牌数减去最大匹配

重叠部分很容易判断。。

代码：

#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <map>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
using namespace std;
int g[1005][1005];
int vis[1005];
int link[1005];
struct Point
{
    int x,y;
    Point(){}
    Point(int a,int b):x(a),y(b){}
    bool operator ==(const Point&a)const
    {
        return x==a.x && y==a.y;
    }

} ph[1005],pl[1005];
int n,m;
int judge(Point a , Point b)
{
    if(a==b || Point(a.x+1,a.y)==b || Point(a.x+1,a.y)== Point(b.x,b.y+1)|| a== Point(b.x,b.y+1))
    {
        return 1;
    }
    return 0;
}
int dfs(int u)
{
    for(int i=0;i<m;i++)
    {
        if(!vis[i] && g[u][i])
        {
            vis[i]=1;
            if(link[i]==-1 || dfs (link[i]))
            {
                link[i]=u;
                return 1;
            }
        }
    }
    return 0;
}
int main()
{
    while(scanf("%d%d",&n,&m) && n && m)
    {
        memset(g,0,sizeof(g));
        for(int i=0; i<n; i++)
            scanf("%d %d",&ph[i].x,&ph[i].y);
        for(int i=0; i<m; i++)
            scanf("%d %d",&pl[i].x,&pl[i].y);
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<m; j++)
            {
                if(judge(ph[i],pl[j]))
                    g[i][j]=1;
            }
        }
        memset(link,-1,sizeof(link));
        int ans=0;
        for(int i=0; i<n; i++)
        {
            memset(vis,0,sizeof(vis));
            ans+=dfs(i);
        }
        printf("%d\n",n+m-ans);
    }
    return 0;
}