Noip 备战篇（三）

最新推荐文章于 2018-09-18 23:03:00 发布

原创最新推荐文章于 2018-09-18 23:03:00 发布 · 387 阅读

0 ·

CC 4.0 BY-SA版权

【小K 的农场(farm)】 new oj 1750
题目大意：现在有若干个农场，每个农场里面有若干个作物，现在给你一些限制条件，具体是：

如果每行的第一个数是1，接下来有三个整数a,b,c，表示农场a 比农场b 至少多种植了c 个单位的作物
如果每行第一个数是2，接下来有三个整数a，b，c，表示农场a 比农场b 至多多种植了c 个单位的作物
如果每行第一个数是3，接下来有两个整数a,b，表示农场a 种植的数量与b一样多

思路：

比较显然的查分约束系统。对于这张图里面的每一个联通块，只要判断一下有没有负环就可以了。但是有个坑爹的地方就是如果你spfa>n 才退出就会超时，所以用栈代替队列就可以比较快的找到负环。但是事实上只要>5退出就可以（不太科学）。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<cstring>
#include<queue>
using namespace std;
const int imax=10000+229;
const int bmax=2*imax;
const int inf=1000000229;
int n,m;
int num,head[imax],to[bmax],next[bmax],c[bmax];
bool flag[imax],ok[imax];

void add(int u,int v,int val){
    to[num]=v; next[num]=head[u]; c[num]=val; head[u]=num++;
}

void iread()
{
    scanf("%d%d",&n,&m);
    int f; int a,b,val;
    memset(head,-1,sizeof(head)); 
    for(int i=1;i<=m;i++)
    {
        scanf("%d",&f);
        if(f==1)
        {
             scanf("%d%d%d",&a,&b,&val);
             flag[a]=1; flag[b]=1;
             add(a,b,-val);
        }
        else if(f==2)
        {
            scanf("%d%d%d",&a,&b,&val);
            flag[a]=1; flag[b]=1;
            add(b,a,val); add(a,b,0);   
        }
        else
        {
            scanf("%d%d",&a,&b);
            flag[a]=1; flag[b]=1;
            add(a,b,0); add(b,a,0);
        }
    }   
}

int d[imax],cal[imax];
bool vis[imax];
queue<int> q;
bool spfa(int x)
{
    for(int i=1;i<=10000;i++) 
        { d[i]=inf; cal[i]=0; vis[i]=0; }
    d[x]=0; vis[x]=1;
    q.push(x);
    while(!q.empty())
    {
        int u=q.front();
        q.pop(); 
        vis[u]=0; ok[u]=1;
        cal[u]++;
        if(cal[u]>10) {return false;}
        for(int i=head[u];i!=-1;i=next[i])
        {
            if(d[to[i]]>d[u]+c[i])
            {
                d[to[i]]=d[u]+c[i];
                if(!vis[to[i]]) { vis[to[i]]=1; q.push(to[i]);} 
            }   
        } 
    }   
    return true;
}

void iwork()
{
    for(int i=1;i<=10000;i++)
        if(flag[i] && !ok[i])
        {
            if(!spfa(i)) { puts("No"); return; }    
        }   
    puts("Yes");
}

int main()
{
    iread();
    iwork();
    return 0;
}

【第二题就是仓库建设原题】

【小M 的作物(crop)】 new oj 1752

题目大意：
现在给你两个农场，以及一些作物。每个作物放在A会有一个价值，在B会有另一个价值。但是有一些作物在一起的话会有特殊的额外收益。所以现在求最大的收益。
（对于100%的数据，1 <= k< n（作物） <= 1000 ,0 < m（特殊组合） <=1000 保证所有数据及结果不超过2*10^9。）

思路

一看就应该是网络流。关键是怎么建图。
如果不考虑特殊的收益的话。可以只要建一排的点，然后从s->i连a[i], i->T连b[i],即可，这样求一个最小割就可以得出ans=all-Maxflow。因为每个点只会在一个集合之中，而最小割又能保证得出的是a[i]和b[i]中的Min。
再次考虑特殊情况：可以这样建图，对于每一种特殊情况。只要建立相应的两个点，一个在左边，一个在右边。（A, B）A->B连一个a[i]，B->T连一个，然后A向每个对应的作物连inf的边，每个对应作物向B连一条inf的边。这样再次进行最小割就可以了。
(因为inf的边不可能成为割边，所以最小割的是a[i]和b[i]的边。)

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<cstring>
#include<queue>
#define F(i,begin,end) for(int i=begin;i<=end;i++)
using namespace std;
const int imax=1000+229;
const int dmax=4000+229;
const int bmax=4000000+229;
const int inf=1000000229;
int n,m,k,a[imax],b[imax];
int num,head[dmax],to[bmax],re[bmax],next[bmax];
int ans,S,T;

void iadd(int u,int v,int flow){
    to[num]=v;  re[num]=flow;
    next[num]=head[u]; head[u]=num++;
}

void add(int u,int v,int flow){
    iadd(u,v,flow);
    iadd(v,u,0);
}

void iread()
{
    scanf("%d",&n);
    S=0; T=3229;
    memset(head,-1,sizeof(head));
    for(int i=1;i<=n;i++)
    {
         scanf("%d",&a[i]); ans+=a[i];
         add(S,1000+i,a[i]);
    }
    for(int i=1;i<=n;i++)
    {
         scanf("%d",&b[i]); ans+=b[i];
         add(1000+i,T,b[i]);     
    }

    scanf("%d",&m);
    int cl1,cl2;
    int now,now2;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&k,&cl1,&cl2);
        now=i;  
        now2=2000+i; ans+=(cl1+cl2);
        add(S,now,cl1); add(now2,T,cl2); 
        int x;
        for(int j=1;j<=k;j++) 
        {
            scanf("%d",&x);
            add(now,1000+x,inf);
            add(1000+x,now2,inf);
        }
    }       
}

int d[dmax];
queue<int> q;
bool BFS()
{
   memset(d,0,sizeof(d));
   q.push(S);
   d[S]=1;
   while(!q.empty())
   {
       int u=q.front();
       q.pop();
       for(int k=head[u];k!=-1;k=next[k])
       {
           if(re[k] && !d[to[k]])
           {
              d[to[k]]=d[u]+1;
              q.push(to[k]);        
           }        
       }        
   }
   return d[T]>0;    
}

int DFS(int x,int c)
{
   if(x==T || c==0) return c;
   int r=c,f;
   for(int k=head[x];k!=-1;k=next[k])
   {
        if(re[k] && d[to[k]]==d[x]+1)
        {
           f=DFS(to[k],min(re[k],r));
           r-=f; re[k]-=f;  re[k^1]+=f; 
           if(r==0) break;
        }       
   }    
    if(r==c) d[x]=0; // 当前节点无法继续增广；
    return c-r; 
}

void iwork()
{
    int kk=0;
    while(BFS()) { kk+=DFS(S,inf); }    
    printf("%d\n",ans-kk);
}

int main()
{
    iread();
    iwork();
    return 0;
}