Educational Codeforces Round 8 F. Bear and Fair Set 最大流

F. Bear and Fair Set

题目连接：

http://www.codeforces.com/contest/628/problem/F

Description

Limak is a grizzly bear. He is big and dreadful. You were chilling in the forest when you suddenly met him. It's very unfortunate for you. He will eat all your cookies unless you can demonstrate your mathematical skills. To test you, Limak is going to give you a puzzle to solve.

It's a well-known fact that Limak, as every bear, owns a set of numbers. You know some information about the set:

The elements of the set are distinct positive integers.

The number of elements in the set is n. The number n is divisible by 5.

All elements are between 1 and b, inclusive: bears don't know numbers greater than b.

For each r in {0, 1, 2, 3, 4}, the set contains exactly elements that give remainder r when divided by 5. (That is, there are elements divisible by 5, elements of the form 5k + 1, elements of the form 5k + 2, and so on.)

Limak smiles mysteriously and gives you q hints about his set. The i-th hint is the following sentence: "If you only look at elements that are between 1 and upToi, inclusive, you will find exactly quantityi such elements in my set."

In a moment Limak will tell you the actual puzzle, but something doesn't seem right... That smile was very strange. You start to think about a possible reason. Maybe Limak cheated you? Or is he a fair grizzly bear?

Given n, b, q and hints, check whether Limak can be fair, i.e. there exists at least one set satisfying the given conditions. If it's possible then print ''fair". Otherwise, print ''unfair".

Input

The first line contains three integers n, b and q (5 ≤ n ≤ b ≤ 104, 1 ≤ q ≤ 104, n divisible by 5) — the size of the set, the upper limit for numbers in the set and the number of hints.

The next q lines describe the hints. The i-th of them contains two integers upToi and quantityi (1 ≤ upToi ≤ b, 0 ≤ quantityi ≤ n).

Output

Print ''fair" if there exists at least one set that has all the required properties and matches all the given hints. Otherwise, print ''unfair".

Sample Input

10 20 1

10 10

Sample Output

fair

Hint

题意

你有n个数，每个数都不同，且每个数都不大于b。

这n个数中恰好有n/5个数是5的倍数，n/5个数mod5=1,n/5个数mod5=2，n/5个数mod5=3，n/5个数mod5=4

然后有q个限制

限制说，[1,upToi]内，你选了quantityi个数

问你这个可不可能

题解：

网络流rush一波就好了

首先意识到，关于5的倍数这个东西，他是独立的，显然我选择mod=2的，不会选到mod=3的东西。

然后对于每个限制，我们都把区间给划开

本来是[1,l1] 1,l2的，我们变成[1,l1][l1+1,l2]，这样分开来

然后我们根据这个来建立网络流去跑就好了

原点连5种余数，流量为n/5;5种余数分别连向每个区间，流量为每个区间的区间内该余数的数的数量；然后每个区间连向T，流量为该区间的大小

然后最大流看看是不是满流就好了

代码

#include<bits/stdc++.h>
using namespace std;
const int MAXN=300000,MAXM=300000,inf=1e9;
struct Edge
{
    int v,c,f,nx;
    Edge() {}
    Edge(int v,int c,int f,int nx):v(v),c(c),f(f),nx(nx) {}
} E[MAXM];
int G[MAXN],cur[MAXN],pre[MAXN],dis[MAXN],gap[MAXN],sz;
void init()
{
    sz=0; memset(G,-1,sizeof(G));
}
void link(int u,int v,int c)
{
    E[sz]=Edge(v,c,0,G[u]); G[u]=sz++;
    E[sz]=Edge(u,0,0,G[v]); G[v]=sz++;
}
bool bfs(int S,int T)
{
    static int Q[MAXN]; memset(dis,-1,sizeof(dis));
    dis[S]=0; Q[0]=S;
    for (int h=0,t=1,u,v,it;h<t;++h)
    {
        for (u=Q[h],it=G[u];~it;it=E[it].nx)
        {
            if (dis[v=E[it].v]==-1&&E[it].c>E[it].f)
            {
                dis[v]=dis[u]+1; Q[t++]=v;
            }
        }
    }
    return dis[T]!=-1;
}
int dfs(int u,int T,int low)
{
    if (u==T) return low;
    int ret=0,tmp,v;
    for (int &it=cur[u];~it&&ret<low;it=E[it].nx)
    {
        if (dis[v=E[it].v]==dis[u]+1&&E[it].c>E[it].f)
        {
            if (tmp=dfs(v,T,min(low-ret,E[it].c-E[it].f)))
            {
                ret+=tmp; E[it].f+=tmp; E[it^1].f-=tmp;
            }
        }
    }
    if (!ret) dis[u]=-1; return ret;
}
int dinic(int S,int T)
{
    int maxflow=0,tmp;
    while (bfs(S,T))
    {
        memcpy(cur,G,sizeof(G));
        while (tmp=dfs(S,T,inf)) maxflow+=tmp;
    }
    return maxflow;
}
int n,b,q;
pair<int,int>p[MAXN];
int main()
{
    init();
    memset(p,0,sizeof(p));
    scanf("%d%d%d",&n,&b,&q);
    for(int i=1;i<=q;i++)
        scanf("%d%d",&p[i].first,&p[i].second);
    q++;p[q].first=b,p[q].second=n;
    sort(p+1,p+1+q);
    for(int i=1;i<=q;i++)
    {
        if(p[i].second<p[i-1].second)return puts("unfair");
        if((p[i].first==p[i-1].first)&&(p[i].second!=p[i-1].second))return puts("unfair");
    }
    int S=0,T=q+7;
    for(int i=1;i<=5;i++)
        link(S,i,n/5);
    for(int i=1;i<=q;i++)
    {
        link(i+5,T,p[i].second-p[i-1].second);
        for(int j=1;j<=5;j++)
        {
            int num1 = p[i].first/5+(p[i].first%5>=j);
            int num2 = p[i-1].first/5+(p[i-1].first%5>=j);
            link(j,i+5,num1-num2);
        }
    }
    if(dinic(S,T)!=n)printf("unfair\n");
    else printf("fair\n");
}