【查询类博客】金牌导航代码

3

3-1

3-1-1

#include<bits/stdc++.h>
using namespace std;

const int N =505;

int match[N];

int g[N][N];

bool vis[N];

int n,k;

int ans;

bool Ntr(int u)
{
    for(int i=1;i<=n;i++)
    {
        if(g[u][i] && !vis[i])
        {
            vis[i]=1;
            if(!match[i] || Ntr(match[i]))
            {
                match[i]=u;
                return 1;
            }
        }
    }
    return 0;
}

int main()
{
    cin>>n>>k;
    for(int i=1;i<=k;i++)
    {
        int u,v;
        cin>>u>>v;
        g[u][v]=1;
    }
    for(int i=1;i<=n;i++)
    {
        memset(vis,0,sizeof(vis));
        if(Ntr(i)) ans++;
    }
    cout<<ans;
    return 0;
}

3-1-2

#include<bits/stdc++.h>
using namespace std;

const int N = 205;
const int M = 205*205;

int n;
int idx;
int g[N][N];
int ans;

vector<int> lft;

vector<int> e[M];
bool vis[M];
int match[M];

inline void Link(int u,int v)
{
    if(u && v)
    {
        e[u].push_back(v);
        // cout<<u<<" "<<v<<endl;
    }
}

bool Ntr(int u)
{
    for(int v : e[u])
    {
        if(!vis[v])
        {
            vis[v]=1;
            if(!match[v] || Ntr(match[v]))
            {
                match[v]=u;
                return 1;
            }
        }
    }
    return 0;
}

int main()
{
    cin>>n;
    char c=getchar();
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            char ch=getchar();
            if(ch=='0')
            {
                g[i][j]=++idx;
                if((i^j)&1) lft.push_back(idx);
            }
        }
        c=getchar();
    }

    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(g[i][j])
            {
                if(i-2>=1)
                {
                    if(j-1>=1) Link(g[i][j],g[i-2][j-1]);
                    if(j+1<=n) Link(g[i][j],g[i-2][j+1]);
                }
                if(i-1>=1)
                {
                    if(j-2>=1) Link(g[i][j],g[i-1][j-2]);
                    if(j+2<=n) Link(g[i][j],g[i-1][j+2]);
                }
                if(i+2<=n)
                {
                    if(j-1>=1) Link(g[i][j],g[i+2][j-1]);
                    if(j+1<=n) Link(g[i][j],g[i+2][j+1]);
                }
                if(i+1<=n)
                {
                    if(j-2>=1) Link(g[i][j],g[i+1][j-2]);
                    if(j+2<=n) Link(g[i][j],g[i+1][j+2]);
                }
            }
        }
    }
    for(int u : lft)
    {
        for(int i=1;i<=idx;i++) vis[i]=0;
        if (Ntr(u)) ans++;
    }
    cout<<idx-ans;
    return 0;
}

3-1-3

#include<bits/stdc++.h>
using namespace std;

inline void Read(int &ans)
{
    ans=0;
    bool flag=0;
    char ch=getchar();
    while(~ch && !isdigit(ch))
    {
        flag|=(ch=='-');
        ch=getchar();
    }
    while(~ch && isdigit(ch))
    {
        ans=ans*10+(ch^48);
        ch=getchar();
    }
    if(flag) ans=-ans;
}

char c[100];
inline void Write(int ans)
{
    if(ans<0)
    {
        putchar('-');
        ans=-ans;
    }
    int cnt=0;
    while(ans)
    {
        c[++cnt]=(ans%10);
        ans/=10;
    }
    while(cnt)
    {
        putchar(c[cnt]^48);
        cnt--;
    }
}

inline int Dis(int x,int y,int xx,int yy) {return abs(x-xx)+abs(y-yy);}

struct people {int x,y,xx,yy,t;}node[505];

int n,ans;
bool vis[505];
int match[505];

vector<int> e[505];

inline bool Link(people a,people b)
{
    int t=a.t+Dis(a.x,a.y,a.xx,a.yy)+Dis(a.xx,a.yy,b.x,b.y);
    if(t<b.t) return true;
    else return false;
}

bool Ntr(int u)
{
    for(int v : e[u])
    {
        if(!vis[v])
        {
            vis[v]=1;
            if(!match[v] || Ntr(match[v]))
            {
                match[v]=u;
                return 1;
            }
        }
    }
    return 0;
}

int main()
{
    // freopen("working.out","w",stdout);
    int T;
    cin>>T;
    while(T--)
    {
        cin>>n;
        for(int i=1;i<=n;i++) e[i].clear();
        memset(match,0,sizeof(match));
        for(int i=1;i<=n;i++) 
        {
            int t=0;
            Read(t);
            t*=60;
            int x;
            Read(x);
            t+=x;
            Read(node[i].x);
            Read(node[i].y);
            Read(node[i].xx);
            Read(node[i].yy);
            node[i].t=t;
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=i+1;j<=n;j++)
            {
                if(Link(node[i],node[j])) {e[i].push_back(j);}
            }
        }
        ans=n;
        for(int i=1;i<=n;i++) 
        {
            memset(vis,0,sizeof(vis));
            if(Ntr(i)) ans--;
        }
        cout<<ans<<endl;
    }
    return 0;
}

3-1-4

#include<bits/stdc++.h>
using namespace std;

int n,m;

vector<int> lft,rit;
vector<int> e[10500];

int g[105][105];
int idx;

bool ans[105*105];
int match[10500];
bool vis[10500];


inline void Link(int i,int j)
{
    if(g[i-1][j]) e[g[i][j]].push_back(g[i-1][j]);
    if(g[i+1][j]) e[g[i][j]].push_back(g[i+1][j]);
    if(g[i][j-1]) e[g[i][j]].push_back(g[i][j-1]);
    if(g[i][j+1]) e[g[i][j]].push_back(g[i][j+1]);
}

bool Ntr(int u)
{
    for(int v : e[u])
    {
        if(!vis[v])
        {
            vis[v]=1;
            if(!match[v] || Ntr(match[v]))
            {
                match[v]=u,match[u]=v;
                return 1;
            }
        }
    }
    return 0;
}

void Dfs(int u)
{
    if(ans[u]) return ;
    ans[u]=1;
    for(int v : e[u])
    {
        if(match[v]!=u) Dfs(match[v]);
    }
}

int main()
{
    cin>>n>>m;
    getchar();
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            char ch=getchar();
            if(ch=='.') g[i][j]=(i-1)*m+j;
        }
        getchar();
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(g[i][j])
            {
                if((i^j)&1) lft.push_back(g[i][j]);
                else rit.push_back(g[i][j]);
                Link(i,j);
            }
        }
    }
    for(int u : lft)
    {
        memset(vis,0,sizeof(vis));
        Ntr(u);
    }
    bool lose=1;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(g[i][j])
            {
                int u=g[i][j];
                if(!match[u])
                {
                    lose=0;
                    Dfs(u);
                }
            }
        }
    }
    if(lose)
    {
        cout<<"LOSE";
        return 0;
    }
    else 
    {
        cout<<"WIN"<<endl;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                if(ans[g[i][j]])
                {
                    cout<<i<<" "<<j<<endl;
                }
            }
        }
    }
    return 0;
}

3-1-6

#include<bits/stdc++.h>
using namespace std;

const int N  =105;
const int  M = 1005;

int n,m;
vector<int> e[N];
int match[N];
bool vis[N];
bool g[N][N];

int ans;

void Floyd()
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            for(int k=1;k<=n;k++)
            {
                if(g[i][k] && g[k][j]) g[i][j]=1;
            }
        }
    }
}

bool Ntr(int u)
{
    for(int i=1;i<=n;i++)
    {
        if(!g[u][i]) continue;
        int v=i;
        if(!vis[v])
        {
            vis[v]=1;
            if(!match[v] || Ntr(match[v]))
            {
                match[v]=u;
                return 1;
            }
        }
    }
    return 0;
}

int main()
{
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        g[u][v]=1;
    }
    Floyd();
    ans=n;
    for(int i=1;i<=n;i++)
    {
        memset(vis,0,sizeof(vis));
        if(Ntr(i)) ans--;
    }
    cout<<ans;
    return 0;
}

3-2

3-2-1

#include<bits/stdc++.h>
using namespace std;

const int N = 205;
const int M = 205;

const int INF = 0x3f3f3f3f;

int edgeid=2;
int head[N];
struct edge
{
    int v,w,nxt;
}e[M*2];
inline void addedge(int u,int v,int w)
{
    e[edgeid].v=v;
    e[edgeid].w=w;
    e[edgeid].nxt=head[u];
    head[u]=edgeid;
    edgeid++;
}

/*inline void addedge(int u,int v,int w)
{
    edgeid+=2;
    e[edgeid].v=v;
    e[edgeid].w=w;
    e[edgeid].nxt=head[u];
    head[u]=edgeid;
    e[edgeid^1].v=u;
    e[edgeid^1].w=0;
    e[edgeid^1].nxt=head[v];
    head[v]=edgeid^1;
}*/


int n,m;
int ans;
int cur[N];
int dis[N];

int st,ed;

queue<int> q;
bool Bfs()
{
    while(!q.empty()) q.pop();
    for(int i=1;i<=n;i++)
    {
        cur[i]=head[i]; //重置当前弧优化
        dis[i]=0; //重置距离
    }
    q.push(st);
    dis[st]=1;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=head[u];i;i=e[i].nxt)
        {
            int v=e[i].v;
            if(e[i].w && !dis[v]) 
            {
                dis[v]=dis[u]+1;
                if(v==ed) return 1;
                q.push(v);
            }
        }
    }
    return 0;
}

int Dfs(int u,int rst)
{
    if(!rst || u==ed) return rst;
    int sum=0;
    for(int i=cur[u];i;i=e[i].nxt) //当前弧优化 确保时间复杂度O(n^2 m)
    {
        int v=e[i].v;
        cur[u]=i;
        int f;
        if(dis[v]==dis[u]+1 && (f=Dfs(v,min(rst,e[i].w))))
        {
            e[i].w-=f;
            e[i^1].w+=f;
            sum+=f;
            rst-=f;
            if(rst==0) break;//余量优化 常数
        }
    }
    if(sum==0) dis[u]=0;//废点优化 常数
    return sum;
}

void Dinic()
{
    while(Bfs())
    {
        ans+=Dfs(1,INF);
    }
}

int main()
{
    cin>>m>>n;
    st=1,ed=n;
    for(int i=1;i<=m;i++)
    {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        addedge(u,v,w);
        addedge(v,u,0);
    }
    Dinic();
    cout<<ans;
    return 0;
}

3-2-2

#include<bits/stdc++.h>
using namespace std;

const int N = 605;
const int M = 2505;

const int INF = (int)0x3f3f3f3f;

int edgeid=1;
int head[N];
struct edge
{
    int v;
    int w;
    int nxt;
}e[N*N*2];
inline void addedge(int u,int v,int w) 
{
    edgeid++;
    e[edgeid].v=v;
    e[edgeid].w=w;
    e[edgeid].nxt=head[u];
    head[u]=edgeid;
}

queue<int> q[M];

int n,m;
int st,ed;

int c[M];

int dep[N];
int cur[N];

int ans;

queue<int> qq;
bool Bfs()
{
    memset(dep,-1,sizeof(dep));
    for(int i=0;i<=n+1;i++) cur[i]=head[i];
    while(!qq.empty()) qq.pop();
    qq.push(st);
    dep[st]=0;
    while(!qq.empty())
    {
        int u=qq.front();
        qq.pop();
        for(int i=head[u];i;i=e[i].nxt)
        {
            int v=e[i].v;
            if(e[i].w && dep[v]==-1)
            {
                dep[v]=dep[u]+1;
                // cout<<v<<" "<<dep[v]<<endl;
                if(v==ed) return 1;
                qq.push(v);
            }
        }
    }
    return 0;
}

int Dfs(int u,int rst)
{
    if(!rst || (u==ed)) return rst;
    int sum=0;
    for(int i=cur[u];i;i=e[i].nxt)
    {
        int v=e[i].v;
        cur[u]=i;
        int f;
        if(dep[v]==dep[u]+1 && (f=Dfs(v,min(rst,e[i].w))))
        {
            e[i].w-=f;
            e[i^1].w+=f;
            sum+=f;
            rst-=f;
            if(rst==0) break;//余量优化 常数
        }
    }
    if(sum==0) dep[u]=0;//废点优化 常数
    return sum;
}


void Dinic()
{
    while(Bfs())
    {
        ans+=Dfs(st,INF);
    }
}

int main()
{
    // freopen("working.in","r",stdin);
    cin>>m>>n;
    st=0,ed=n+1;
    for(int i=1;i<=m;i++)  scanf("%d",&c[i]);
    for(int i=1;i<=n;i++)
    {
        int x;
        scanf("%d",&x);
        for(int j=1;j<=x;j++)
        {
            int z;
            scanf("%d",&z);
            q[z].push(i);
        }
        scanf("%d",&x);
        addedge(i,ed,x);
        addedge(ed,i,0);
    }
    for(int i=1;i<=m;i++)
    {
        if(q[i].empty()) continue;
        addedge(st,q[i].front(),c[i]);
        addedge(q[i].front(),st,0);
        int lst=q[i].front();
        q[i].pop();
        while(!q[i].empty())
        {
            addedge(lst,q[i].front(),INF);
            addedge(q[i].front(),lst,0);
            lst=q[i].front();
            q[i].pop();
        }
    }
    Dinic();
    cout<<ans;
    return 0;
}

3-2-3

#include<bits/stdc++.h>
using namespace std;

#define int long long 
const int N = 45;
const int M = 45;
int INF = 0x7F7F7F7F7F7F7F7F;
int g[N][M];
int n,m;
int x,b,w,W,B,opt;
int st,ed;
int mnx;

int adx[5]={0,0,0,1,-1};
int ady[5]={0,1,-1,0,0};
inline int Point(int i,int j)
{
    return (i-1)*m+j;
}

int edgeid;
int head[N*M];
struct edge
{
    int v,w,nxt;
}e[20*N*M];
void addedge(int u,int v,int w)
{
    // cout<<"add "<<u<<" "<<v<<" "<<w<<endl;
    edgeid++;
    e[edgeid].v=v;
    e[edgeid].w=w;
    e[edgeid].nxt=head[u];
    head[u]=edgeid;
    edgeid++;
    e[edgeid].w=0;
    e[edgeid].v=u;
    e[edgeid].nxt=head[v];
    head[v]=edgeid;
}

int dep[N*M];
int cur[N*M];

queue<int> q;
bool Bfs()
{
    while(!q.empty()) q.pop();
    memset(dep,0,sizeof(dep));
    for(int i=0;i<=n*m+1;i++) cur[i]=head[i];
    q.push(st);
    dep[st]=1;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=head[u];i;i=e[i].nxt)
        {
            int v=e[i].v;
            if(e[i].w && !dep[v])
            {
                dep[v]=dep[u]+1;
                q.push(v);
            }
        }
    }
    return dep[ed];
}

int Dfs(int u,int rst)
{
    if(!rst || u==ed) return rst;
    int sum=0;
    for(int i=cur[u];i;i=e[i].nxt)
    {
        cur[u]=i;
        int v=e[i].v;
        int f;
        if(dep[v]==dep[u]+1 && (f=Dfs(v,min(rst,e[i].w))))
        {
            sum+=f;
            rst-=f;
            e[i].w-=f;
            e[i^1].w+=f;
            if(rst==0) break;
        }
    }
    if(sum==0) dep[u]=0;
    return sum;
}

int Dinic()
{
    int ans=0;
    while(Bfs())
    {
        ans+=Dfs(st,INF);
    }
    return ans;
}

bool Check(int p)
{
    st=0,ed=n*m+1;
    int sum=0;
    memset(head,0,sizeof(head));
    edgeid=1;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if((i + j) % 2 == 1) 
            {
                addedge(Point(i,j),ed,p-g[i][j]);
            }
            else 
            {
                addedge(st,Point(i,j),p-g[i][j]);
                sum+=p-g[i][j];
                for(int k=1;k<=4;k++)
                {
                    int ki=i+adx[k];
                    int kj=j+ady[k];
                    if(ki>=1 && ki<=n && kj>=1 && kj<=m)
                    {
                        addedge(Point(i,j),Point(ki,kj),INF);
                    }
                }
            }
        }
    }
    if(Dinic()==sum) return 1;
    return 0;
}

signed  main()
{   
    // freopen("working.in","r",stdin);
    int T;
    cin>>T;
    while(T--)
    {
        x=b=w=W=B=opt=mnx=0;
        cin>>n>>m;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                scanf("%lld",&g[i][j]);
                if((i^j)&1) w+=g[i][j],W++;
                else b+=g[i][j],B++;
                mnx=max(mnx,g[i][j]);
            }
        }
        if(W!=B)
        {
            x=(b-w)/(B-W);
            if(x>=mnx && Check(x))
            {
                cout<<x*W-w<<endl;
                continue;
            }
            else 
            {
                cout<<-1<<endl;
                continue;
            }
        }
        else 
        {
            int l=mnx-1;
            int r=(INF>>1);
            if(w!=b)
            {
                cout<<-1<<endl;
                continue;
            }
            while(l+1<r)
            {
                int mid=(l+r)>>1;
                if(Check(mid)) r=mid;
                else l=mid;
            }
            if(r==(INF>>1))
            {
                cout<<-1<<endl;
                continue;
            }
            else 
            {
                cout<<B*r-b<<endl;
                continue;
            }
        }
    }
    return 0;

}