大白叔叔专题之匹配、网络流（二）（第一题不是呐~）

1、poj 2195 Going Home（二分图最小权匹配）

　　题意：图上有n个房子，n个人，现在安排每个人回到一所房间，求最小的步数和。

　　思路：KM算法模板题。注意反向。

　　附：推荐km算法大神博客：

　　　　http://blog.sina.com.cn/s/blog_691ce2b701016reh.html

　　　　http://www.cnblogs.com/wenruo/p/5264235.html

　　　　http://blog.csdn.net/sixdaycoder/article/details/47720471

　　　　http://blog.csdn.net/zxn0803/article/details/49999267

　　　　http://www.cnblogs.com/Lanly/p/6291214.html

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define N 105
#define INF 0x3f3f3f
char maze[N][N];
int mp[N][N], match[N], lx[N], ly[N], visx[N], visy[N], slack[N];
int n, m,ny,nx;
//lx,ly为顶标，nx,ny分别为x点集y点集的个数
//match数组记录右边y端点所连的左端点x，visx，visy数组记录是否曾访问过，也是判断是否在增广路上
struct node
{
    int a, b;
}sa[N], sb[N];
//KM求二分图最小匹配模板：只需把权值都变成负的，再用KM算出最大权匹配，然后取反就是答案
//学习KM地址http://blog.sina.com.cn/s/blog_691ce2b701016reh.html
bool dfs(int x)
{
    visx[x] = 1;
    for (int y = 1; y <= ny; y++)
    {
        if (visy[y]) continue;
        int t = lx[x] + ly[y] - mp[x][y];
        if (t == 0)//(x,y)在相等子图中
        {
            visy[y] = 1;
            if (match[y] == -1 || dfs(match[y]))
            {//注意这里要搜match[y]而不是y，因为我们只搜索x侧的，不需要搜索y侧的 
                match[y] = x;
                return true;
            }
        }
        else if (slack[y]>t) slack[y] = t;//(x,y)不在相等子图中且y不在交错树中slack 取最小的
    }
    return false;
}

int KM()
{
    memset(match, -1, sizeof(match));
    memset(lx, -INF, sizeof(lx));
    memset(ly, 0, sizeof(ly));
    for (int i = 1; i <= nx; i++)
    {
        for (int j = 1; j <= ny; j++)
        {//lx初始化为与它关联边中最大的
            if (mp[i][j]>lx[i]) lx[i] = mp[i][j];
        }
    }
    for (int x = 1; x <= nx; x++)
    {
        for (int y = 1; y <= ny; y++)
            slack[y] = INF; //每次换新的x结点都要初始化slack
        while (1)
        {
            memset(visx, 0, sizeof(visx));
            memset(visy, 0, sizeof(visy));//这两个初始化必须放在这里,因此每次dfs()都要更新
            if (dfs(x)) break;
            //若成功（找到了增广轨），则该点增广完成，进入下一个点的增广
            //若失败（没有找到增广轨），则需要改变一些点的标号，使得图中可行边的数量增加。方法为：将所有在增广轨中（就是在增广过程中遍历到）的X方点的标号全部减去一个常数d，所有在增广轨中的Y方点的标号全部加上一个常数d.
            int d = INF;
            for (int y = 1; y <= ny; y++)
            {
                if (!visy[y] && d>slack[y]) d = slack[y];
            }
            for (int x = 1; x <= nx; x++)
            {
                if (visx[x]) lx[x] -= d;
            }
            for (int y = 1; y <= ny; y++)
            {//修改顶标后，要把所有不在交错树中的Y顶点的slack值都减去d,这是因为lx[i] 减小了delta,slack[j] = min(lx[i] + ly[j] -w[i][j]) --j不属于交错树--也需要减少delta，第二类边
                if (visy[y]) ly[y] += d;
                else slack[y] -= d;
            }
        }
    }
    int res = 0;
    for (int i = 1; i <= ny; i++)
    {
        if (match[i]>-1) res += mp[match[i]][i];
    }
    return res;
}

int main()
{
    int n, m;
    while (~scanf("%d%d", &n, &m))
    {
        if (n + m == 0) break;
        for (int i = 1; i <= n; i++)
        {
            scanf("%s", maze[i] + 1);
        }
        int cnt1 = 0, cnt2 = 0;
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= m; j++)
            {
                if (maze[i][j] == 'm')
                {
                    sa[++cnt1].a = i;
                    sa[cnt1].b = j;
                }
                if (maze[i][j] == 'H')
                {
                    sb[++cnt2].a = i;
                    sb[cnt2].b = j;
                }
            }
        }
        int cnt = cnt1;
        for (int i = 1; i <= cnt1; i++)
        {
            for (int j = 1; j <= cnt2; j++)
            {
                mp[i][j] = abs(sa[i].a - sb[j].a) + abs(sa[i].b - sb[j].b);
                mp[i][j] = -mp[i][j];//取反求最大权匹配（也可以用一个极大值减去原来的值求最大权匹配）
            }
        }
        ny = nx = cnt;
        printf("%d
", -KM());//再取反则为最小权
    }
    return 0;
}

 2、uva 11383 Golden Tiger Claw

　　题意：n*n的矩阵，现在需要确定row和col数组，保证在w(i,j)<=row(i)+col(j)的情况下，求row数组和col数组的和的最小值。

　　思路：二分图完美匹配，KM算法。

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int maxn = 510;
const int INF = 0x3f3f3f3f;
int mp[maxn][maxn], match[maxn], lx[maxn], ly[maxn], visx[maxn], visy[maxn], slack[maxn];
int n, nx, ny;
//lx,ly为顶标，nx,ny分别为x点集y点集的个数
//match数组记录右边y端点所连的左端点x，visx，visy数组记录是否曾访问过，也是判断是否在增广路上
//KM求二分图最小匹配模板：只需把权值都变成负的，再用KM算出最大权匹配，然后取反就是答案

bool dfs(int x)
{
    visx[x] = 1;
    for (int y = 1; y <= ny; y++)
    {
        if (visy[y]) continue;
        int t = lx[x] + ly[y] - mp[x][y];
        if (t == 0)
        {
            visy[y] = 1;
            if (match[y] == -1 || dfs(match[y]))
            {
                match[y] = x;
                return true;
            }
        }
        else if (slack[y] > t) slack[y] = t;
    }
    return false;
}
int KM()
{
    //初始化
    memset(match, -1, sizeof(match));
    memset(lx, - INF, sizeof(lx));
    memset(ly, 0, sizeof(ly));
    for (int i = 1; i <= nx; i++)
    {
        for (int j = 1; j <= ny; j++)
        {
            if (mp[i][j] > lx[i]) lx[i] = mp[i][j];
        }
    }
    for (int x = 1; x <= nx; x++)
    {
        for (int y = 1; y <= ny; y++) slack[y] = INF;
        while (1)
        {
            memset(visx, 0, sizeof(visx));
            memset(visy, 0, sizeof(visy));
            if (dfs(x)) break;
            int d = INF;
            for (int y = 1; y <= ny; y++)
            {
                if (!visy[y] && d > slack[y]) d = slack[y];
            }
            for (int x = 1; x <= nx; x++)
            {
                if (visx[x]) lx[x] -= d;
            }
            for (int y = 1; y <= ny; y++)
            {
                if (visy[y]) ly[y] += d;
                else slack[y] -= d;
            }
        }
    }
    int res = 0;
    for (int i = 1; i <= ny; i++)
    {
        if (match[i] > -1) res += mp[match[i]][i];
    }
    return res;
}
int main()
{
    while (~scanf("%d", &n))
    {
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                scanf("%d", &mp[i][j]);
                mp[i][j] = mp[i][j];
            }
        }
        nx = ny = n;
        int ans = KM();
        for (int i = 1; i <= n; i++)
        {
            if (i > 1) printf(" %d", lx[i]);
            else printf("%d", lx[i]);
        }
        printf("
");
        for (int i = 1; i <= n; i++)
        {
            if (i > 1) printf(" %d", ly[i]);
            else printf("%d", ly[i]);
        }
        printf("
");
        printf("%d
",ans);
    }
    return 0;
}

 3、uvalive 2238 Fixed Partition Memory Management

　　题意：有m个内存，n个程序，每个程序对应不同的内存大小有不同的运行时间。该程序对应已知的内存单元的时间为对应的取下线最接近的时间。求所有程序的总结束时间的平均值最小。

　　思路：对于在一个内存中的情况：设该内存中有K个程序。其运行时间分别为t1,t2……tk，则第i个程序结束时间Ti=t1+t2+……+ti，所有程序运行时间之和为kt1+(k-1)t2+(k-2)t3+……+tk。即对于在内存区域j中倒数第p个执行的程序i来说，其对于总的运行时间的贡献为p*Tij，Tij为第i个程序在第j个内存区域内运行的时间。二分图最小权值匹配，KM算法。

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int maxm = 15;
const int maxn = 55;
const int INF = 0x3f3f3f3f;
int mp[maxn][maxn*maxm],lx[maxn],ly[maxn*maxm],slack[maxn*maxm],match[maxn*maxm],visx[maxn],visy[maxn*maxm];
int m, n,nx,ny;

int totmem[maxm];
struct node
{
    int k, mem[maxm], tm[maxm];
}pg[maxn];

struct re
{
    int id, l, r;
}result[maxn];
bool dfs(int x)
{
    visx[x] = 1;
    for (int y = 1; y <= ny; y++)
    {
        if (visy[y])continue;
        int t = lx[x] + ly[y] - mp[x][y];
        if (t == 0)
        {
            visy[y] = 1;
            if (match[y] == -1 || dfs(match[y]))
            {
                match[y] = x;
                return true;
            }
        }
        else if (slack[y] > t) slack[y] = t;
    }
    return false;
}

void KM()
{
    memset(match, -1, sizeof(match));
    memset(lx, -INF, sizeof(lx));
    memset(ly, 0, sizeof(ly));
    for (int i = 1; i <= nx; i++)
    {
        for (int j = 1; j <= ny; j++)
        {
            if (mp[i][j] > lx[i]) lx[i] = mp[i][j];
        }
    }

    for (int x = 1; x <= nx; x++)
    {
        for (int y = 1; y <= ny; y++) slack[y] = INF;
        while (1)
        {
            memset(visx, 0, sizeof(visx));
            memset(visy, 0, sizeof(visy));

            if (dfs(x)) break;
            int d = INF;
            for (int y = 1; y <= ny; y++)
            {
                if (!visy[y] && d > slack[y]) d = slack[y];
            }
            for (int xx = 1; xx <= nx; xx++)
            {
                if (visx[xx]) lx[xx] -= d;
            }
            for (int y = 1; y <= ny; y++)
            {
                if (visy[y]) ly[y]+= d;
                else slack[y] -= d;
            }
        }
    }
}

void Oput()
{
    int ans = 0;
    for (int i = 1; i <= nx; i++) ans += lx[i];
    for (int i = 1; i <= ny; i++) ans += ly[i];
    printf("Average turnaround time = %.2lf
", n?-1.0*ans / n:0);
    int time[11];//记录每个内存当前运行结束时间
    memset(time, 0, sizeof(time));
    for (int i = 1; i <= m; i++)
    {//枚举内存
        int p;
        for (p = 1; p <= n; p++) if (match[(i - 1)*n + p]==-1) break;//找到该内存的第一个程序位置
        for (p = p - 1; p >= 1; --p)
        {
            int x = match[(i - 1)*n + p];//所对应的程序
            result[x].id = i;//程序所对应的内存
            result[x].l = time[i];
            time[i] += (-mp[x][(i - 1)*n + p] / p);
            result[x].r = time[i];
        }
    }
    for (int i = 1; i <= n; i++)
    {
        printf("Program %d runs in region %d from %d to %d
", i, result[i].id, result[i].l, result[i].r);
    }
}


int main()
{
    int Case = 1;
    while (~scanf("%d%d", &m, &n)&&n&&m)
    {
        for (int i = 1; i <= m; i++) scanf("%d", &totmem[i]);
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", &pg[i].k);
            for (int j = 1; j <= pg[i].k; j++) scanf("%d%d", &pg[i].mem[j], &pg[i].tm[j]);
        }
        for (int i = 1; i <= n; i++)
        {//枚举当前程序
            for (int j = 1; j <= m; j++)
            {//枚举当前内存
                int tmp;//在当前内存的运行时间
                if (totmem[j] < pg[i].mem[1]) tmp = INF;
                else
                {
                    int pos;
                    for (pos = 1; pos <= pg[i].k; pos++)
                    {
                        if (pg[i].mem[pos] > totmem[j]) break;
                    }
                    tmp = pg[i].tm[pos - 1];
                }
                for (int k = 1; k <= n; k++)
                {//当前程序在当前内存是倒数第k个程序，则对总时间的贡献为k*tmp
                    if (tmp == INF) mp[i][(j - 1)*n + k] = -INF;
                    else mp[i][(j - 1)*n + k] = -k*tmp;//求最小权匹配，取负
                }
            }
        }
        nx = n, ny = n*m;
        KM();
        if (Case > 1) printf("
");
        printf("Case %d
", Case++);
        Oput();
    }
    return 0;
}

 4、uvalive 3989 Ladies' Choice

　　题意：有n个女孩，n个男孩，现在需要匹配出n对男孩和女孩。对于每个女孩，按照喜欢程度有降序的男生order，对于男生也一样。现在要求以女生优先，保证在能匹配全部的情况下，每个女生的选择都是最好的。

　　思路：稳定婚姻问题·稳定匹配·GS算法

//稳定婚姻问题

#include<iostream>
#include<queue>
#include<cstdio>
using namespace std;
const int maxn = 1010;

struct gs//Gale - Shapley算法
{//女士优先
    int n;
    int girl_pre[maxn][maxn];
    int boy_pre[maxn][maxn];
    int girl_match[maxn], boy_match[maxn];
    int next[maxn];
    queue<int>q;//未开始选择的女孩

    void engage(int girl, int boy)
    {//匹配
        int pre = boy_match[boy];
        if (pre)
        {
            girl_match[pre] = 0;
            q.push(pre);
        }
        girl_match[girl] = boy;
        boy_match[boy] = girl;
    }

    void read()
    {
        scanf("%d", &n);
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= n; j++) scanf("%d", &girl_pre[i][j]);
            next[i] = 1;//下次等待选择
            girl_match[i] = 0;
            q.push(i);//加入未选择的女生队列
        }
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                int p;
                scanf("%d", &p);
                boy_pre[i][p] = j;//在i男生心中p女孩的排名
            }
            boy_match[i] = 0;
        }
    }

    void solve()
    {
        while (!q.empty())
        {
            int girl = q.front();
            q.pop();
            int boy = girl_pre[girl][next[girl]++];
            if (!boy_match[boy]) engage(girl, boy);//如果该女孩喜欢的男孩没有被选
            else if (boy_pre[boy][girl] < boy_pre[boy][boy_match[boy]]) engage(girl, boy);//或者该女孩喜欢的男孩的当前匹配的女孩喜欢程度不及该女孩
            else q.push(girl);//等待下次匹配
        }
    }

    void print()
    {
        for (int i = 1; i <= n; i++) printf("%d
", girl_match[i]);
    }

}GS;
int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        GS.read();
        GS.solve();
        GS.print();
        if (t) printf("
");
    }


    return 0;
}

 5、uva 11419 SAM I AM

　　题意：有R·C的网格，存在N个敌人，现在有一把武器，每一次发射可以消灭一行或一列的敌人，问最少的发射次数，并且给出发射所在的行和列。

　　思路：首先这是一道求最小点覆盖（用最少的点覆盖所有的边）和输出最小点覆盖集的问题。最小点覆盖数=最大匹配数。怎么求最小点覆盖集呢？详见代码注释~

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn = 1010;
bool mp[maxn][maxn];
int L_match[maxn], R_match[maxn], visL[maxn], visR[maxn];
int n, nl, nr;
bool dfs(int lx)
{
    visL[lx] = true;
    for (int ly = 1; ly <= nr; ly++)
    {
        if (mp[lx][ly] && !visR[ly])
        {
            visR[ly] = true;
            if (!R_match[ly] || dfs(R_match[ly]))
            {//如果当前的ly没有被匹配，或者已经匹配但是和ly匹配的lx'能够和其他ly'匹配，那么当前ly和lx就可以匹配
                L_match[lx] = ly;
                R_match[ly] = lx;
                return true;
            }
        }
    }
    return false;
}

int maxmatch_XYL()
{
    int ans = 0;
    memset(L_match, 0, sizeof(L_match));
    memset(R_match, 0, sizeof(R_match));
    for (int i = 1; i <= nl; i++)
    {
        memset(visL, 0, sizeof(visL));
        memset(visR, 0, sizeof(visR));
        if (dfs(i)) ans++;
    }
    return ans;
}
int main()
{
    while (~scanf("%d%d%d", &nl, &nr, &n))
    {
        if (nl == 0 && nr == 0 && n == 0) break;
        memset(mp, 0, sizeof(mp));
        for (int i = 1; i <= n; i++)
        {
            int x, y;
            scanf("%d%d", &x, &y);
            mp[x][y] = true;
        }
        int ans = maxmatch_XYL();
        printf("%d", ans);
        //寻找最小点覆盖集并输出
        memset(visL, 0, sizeof(visL));
        memset(visR, 0, sizeof(visR));
        //从当前未匹配的lx开始dfs,如果有边a（说明原本假设的最小点覆盖集<即已匹配的lx>不能覆盖到当前dfs到的这一条边），那么原本和边a连接的lx'需更改为a所连接的ly'
        for (int i = 1; i <= nl; i++) if (!L_match[i]) dfs(i);
        for (int i = 1; i <= nl; i++) if (!visL[i]) printf(" r%d", i);//在初期假设的最小点覆盖集中无需删的点
        for (int i = 1; i <= nr; i++) if (visR[i]) printf(" c%d", i);//在dfs过程中lx'更换成的ly'
        printf("
");
    }
    return 0;
}

 6、uvalive 3415 Guardian of Decency

　　题意：如果两个人之间身高差大于40或者同一性别或者喜欢不同的音乐或者喜欢相同的运动，则这两个人可以同时带去出游。问当带出的所有人两两之间至少满足其中一个条件下，所能带走的最多的人？

　　思路：如果两个人4个条件都不符合，那么肯定不能同时带走。现在需要求能带走的最多，则需要最小化不能带走的。当4个条件都不符合时，两人建边，求所选的人两两之间不能连边，即最大独立集问题（选择尽量多的结点，使得任意一条边的两个端点不会同时被选中）。

#include<iostream>
#include<map>
#include<cstdio>
#include<cstring>
#include<string>
#include<cmath>
using namespace std;
const int maxn = 510;
map<string, int>music;
map<string, int>sports;
struct per
{
    int h;
    bool isboy;
    int id_music;
    int id_sports;
}pp[maxn];

int n,nl, nr;
bool mp[maxn][maxn];

int l_match[maxn], r_match[maxn], visl[maxn], visr[maxn];

bool dfs(int lx)
{
    visl[lx] = true;
    for (int ly = 1; ly <= nr; ly++)
    {
        if (mp[lx][ly] && !visr[ly])
        {
            visr[ly] = true;
            if (!r_match[ly] || dfs(r_match[ly]))
            {
                l_match[lx] = ly;
                r_match[ly] = lx;
                return true;
            }
        }
    }
    return false;
}

int maxmatch_XYL()
{
    int ans = 0;
    memset(l_match, 0, sizeof(l_match));
    memset(r_match, 0, sizeof(r_match));
    for (int i = 1; i <= nl; i++)
    {
        memset(visl, 0, sizeof(visl));
        memset(visr, 0, sizeof(visr));
        if (dfs(i)) ans++;
    }
    return ans;
}

bool check(int u, int v)
{//四个条件都不满足建边
    if (abs(pp[u].h - pp[v].h) > 40)
        return false;
    else if(pp[u].isboy == pp[v].isboy)
        return false;
    else if(pp[u].id_music != pp[v].id_music)
        return false; 
    else if(pp[u].id_sports == pp[v].id_sports) 
        return false;
    else return true;
}
int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        nl = nr = n;
        memset(mp, 0, sizeof(mp));
        music.clear();
        sports.clear();
        char tmp[110];
        for (int i = 1; i <= n; i++)
        {
            scanf("%d%s", &pp[i].h,tmp);
            if (tmp[0] == 'M') pp[i].isboy = true;
            else pp[i].isboy = false;
            scanf("%s", tmp);
            if (!music[tmp]) music[tmp] = music.size() + 1;
            pp[i].id_music = music[tmp];
            scanf("%s", tmp);
            if (!sports[tmp]) sports[tmp] = sports.size() + 1;
            pp[i].id_sports = sports[tmp];
        }
        for (int i = 1; i <= nl; i++)
        {
            for (int j = i + 1; j <= nr; j++)
            {
                if (check(i, j)) mp[i][j]=mp[j][i]=true;
            }
        }
        int ans = maxmatch_XYL();
        printf("%d
", n-ans/2);
    }
    return 0;
}

 7、uvalive 3126 Taxi Cab Scheme

　　题意：有n个预约，记录其预约出租车的时间、起始位置、终点位置，并且一辆出租同时只能接送一个预约的乘客。问最少需要多少出租车？

　　思路：如果一辆出租车从第i个预约结束后能赶到第j个预约的地点，且至少能够提前1分钟到，则两点连线。整个问题为有向无环图的最小路径覆盖问题。

最小路径覆盖参考：http://blog.csdn.net/qq_37321281/article/details/77839207

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
int n, nl, nr;
const int maxn = 510;
bool mp[maxn][maxn];
int l_match[maxn], r_match[maxn], visl[maxn], visr[maxn];
bool dfs(int lx)
{
    visl[lx] = true;
    for (int ly = 1; ly <= nr; ly++)
    {
        if (mp[lx][ly] && !visr[ly])
        {
            visr[ly] = true;
            if (!r_match[ly] || dfs(r_match[ly]))
            {
                l_match[lx] = ly;
                r_match[ly] = lx;
                return true;
            }
        }
    }
    return false;
}

int maxmatch()
{
    int ans = 0;
    memset(l_match, 0, sizeof(l_match));
    memset(r_match, 0, sizeof(r_match));
    for (int i = 1; i <= nl; i++)
    {
        memset(visl, 0, sizeof(visl));
        memset(visr, 0, sizeof(visr));
        if (dfs(i)) ans++;
    }
    return ans;
}

struct node
{
    int time;
    int start[2];
    int end[2];
    int cost;
}ps[maxn];

bool check(int from, int to)
{
    if (ps[from].time + ps[from].cost + abs(ps[to].start[0] - ps[from].end[0]) + abs(ps[to].start[1] - ps[from].end[1]) + 1 <= ps[to].time) return true;
    else return false;
}
int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        memset(mp, 0, sizeof(mp));
        scanf("%d",&n);
        nl = nr = n;
        for (int i = 1; i <= n; i++)
        {
            int hh, mm;
            char c;
            scanf("%d%c%d", &hh, &c, &mm);
            ps[i].time = hh * 60 + mm;
            scanf("%d%d", &ps[i].start[0], &ps[i].start[1]);
            scanf("%d%d", &ps[i].end[0], &ps[i].end[1]);
            ps[i].cost = abs(ps[i].start[0] - ps[i].end[0]) + abs(ps[i].start[1] - ps[i].end[1]);
        }
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                if (i!=j&&check(i, j)) mp[i][j]  = true;
            }
        }
        int ans = maxmatch();
        printf("%d
", n - ans);
    }
    return 0;
}

 8、uva 11248 Frequency Hopping

　　题意：有n个基站，用有向边相连，问是否可以从1到N有流量至少为C的最大流？没有的话，是否可以增大一条边的容量而达到目的？

　　思路：dicnic求最大流。增大的边肯定选择最小割中的边。在这之后，从求完最大流后的残余网络求其是否满足条件。

#include<iostream>
#include<queue>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<vector>
using namespace std;
//Dicnic模板
//最小割中，正向边的容量=其流量，逆向边的流量=0。且最小割中所有正向边的容量之和=最大流
const int maxn = 110;
const int maxe = 10010*2;
const int INF = 0x3f3f3f3f;
struct edge
{
    int from, to, cap, flow,next;//边的起点、终点、容量、流量、同起点的下一条边的编号
    edge(int ff=0,int tt=0,int cc=0,int fw=0,int nn=0):from(ff),to(tt),cap(cc),flow(fw),next(nn){ }
    friend bool operator <(const edge&a, const edge&b)
    {
        if (a.from == b.from)
        {
            if (a.to < b.to) return true;
            else return false;
        }
        else if (a.from < b.from) return true;
        else return false;
    }
}Edge[maxe];
int Head[maxn],tmp_head[maxn],totedge;
vector<edge>ans;

struct Dicnic
{
    int n;
    bool vis[maxn];
    int level[maxn];
    int st, ed;
    vector<int>mincut;
    int needflow;

    void Init(int nodes,int source,int dest)
    {
        n = nodes, st = source, ed = dest;
        memset(Head, -1, sizeof(Head));
        totedge = 0;
    }

    void addedge(int from, int to, int cap)
    {
        Edge[totedge] = edge(from, to, cap, 0, Head[from]);
        Head[from] = totedge++;
        Edge[totedge] = edge(to, from, 0, 0, Head[to]);
        Head[to] = totedge++;
    }

    bool Dicnic_bfs()//生成层次图
    {
        queue<int>q;
        int i, u, v;
        memset(level, -1, sizeof(level));
        memset(vis, 0, sizeof(vis));

        q.push(st);
        level[st] = 0;
        vis[st] = true;
        while (!q.empty())
        {
            u = q.front();
            q.pop();
            if (u == ed) return true;
            for (int i = Head[u]; i != -1; i = Edge[i].next)
            {
                v = Edge[i].to;
                if (Edge[i].cap > Edge[i].flow && !vis[v] && level[v] == -1)
                {//保证这条边有剩余容留，属于残量网络
                    vis[v] = true;
                    level[v] = level[u] + 1;
                    q.push(v);
                }
            }
        }
        return false;
    }

    int Dinic_dfs(int u, int maxf)
    {
        if (u == ed||maxf==0) return maxf;

        int flow = 0,f;
        for (int& i = tmp_head[u]; i != -1; i = Edge[i].next)
        {
            int v = Edge[i].to;
            if (Edge[i].cap - Edge[i].flow > 0 && level[v] == level[u] + 1)
            {
                f = Dinic_dfs(v, min(maxf, Edge[i].cap - Edge[i].flow));
                if (f > 0)
                {
                    Edge[i].flow += f;
                    Edge[i ^ 1].flow -= f;
                    flow += f;
                    maxf -= f;
                    if (0 == maxf) break;
                    if (flow >= needflow) return flow;
                }
            }
        }
        return flow;
    }

    int Dinic_maxflow(int needf=INF)//求最大流
    {
        int ret = 0;
        needflow = needf;//需要的流
        while (Dicnic_bfs())
        {
            memcpy(tmp_head, Head, sizeof(Head));
            ret += Dinic_dfs(st, INF);
            if (ret >= needflow) return ret;
        }
        return ret;
    }

    void GetMincut()//获得最小割
    {
        mincut.clear();
        for (int i = 0; i < totedge; i++)
        {
            if (vis[Edge[i].from] && !vis[Edge[i].to] && Edge[i].cap > 0) mincut.push_back(i);
        }
    }

    void Reduce()//求剩余容量
    {
        for (int i = 0; i < totedge; i++) Edge[i].cap -= Edge[i].flow;
    }

    void Clearflow()//把当前流量清零
    {
        for (int i = 0; i < totedge; i++) Edge[i].flow = 0;
    }

}dnc;
int main()
{
    int N, E, C;
    int Case = 1;
    while (~scanf("%d%d%d", &N, &E, &C))
    {
        if (N == 0 && E == 0 && C == 0) break;
        dnc.Init(N, 1, N);
        for (int i = 1; i <= E; i++)
        {
            int from, to, cap;
            scanf("%d%d%d", &from, &to, &cap);
            dnc.addedge(from, to, cap);
        }
        int flow = dnc.Dinic_maxflow(C);
        printf("Case %d: ", Case++);
        if (flow >= C) printf("possible
");
        else
        {
            dnc.GetMincut();
            dnc.Reduce();
            ans.clear();
            int sz = dnc.mincut.size();
            for (int i = 0; i < sz; i++)
            {
                edge &tmp = Edge[dnc.mincut[i]];
                tmp.cap = C;
                dnc.Clearflow();
                if (flow + dnc.Dinic_maxflow(C - flow) >= C) ans.push_back(tmp);
                tmp.cap =0;
            }
            if (ans.empty()) printf("not possible
");
            else
            {
                sort(ans.begin(), ans.end());
                printf("possible option:");
                sz = ans.size();
                for (int i = 0; i < sz; i++)
                {
                    if (i) printf(",");
                    printf("(%d,%d)", ans[i].from, ans[i].to);
                }
                printf("
");
            }
        }
    }
    return 0;
}

 9、uvalive 2957 Bring Them There

　　题意：有N个星球，有M条双向边，需要把K台电脑送S星送到T星。每个飞船只能装一台电脑，且从一个星球到达另一个星球的时间为1天。问最少的天数？

　　思路：首先把N个星球看成时序相关。即对于当前天数day,将（day-1）*N+tunnel[i].from和day*N+tunnel[i].to表示第day天可以从tunnel[i].from星前往unnel[i].to星，反过来同样。同时用（day-1）*N+i连到day*N+i表示该飞船第day天停在i星（保证流能传递到下一天）。接着，则是输出，细节看代码注释。（不明白Dicnic算法调用_dfs(st,INF)为什么会出错……）

　　出错原因：因为之后的每一天都是在原来的残留网络上增边再求最大流，原来就有的边的flow并没有被清。所以每次调用最大流得到的流是当天到达目的地的货物数，根据累加性质，DFS的maxf应当置为needflow-ret。以上为maxf应当置为needflow-ret的解释，但对INF（比needflow-ret大得多），为什么不可以还是没有头绪。。。。

#include<iostream>
#include<queue>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<vector>
using namespace std;

const int maxn = 5010;
const int maxe = 501000;
const int INF = 0x3f3f3f3f;

struct edge
{
    int from, to, cap,flow, next;
    edge(int ff=0,int tt=0,int cc=0,int fw=0,int nn=0):from(ff),to(tt),cap(cc),flow(fw),next(nn){ }
}Edge[maxe];
int Head[maxn], tmp_head[maxn], totedge;

struct Dicnic
{
    int n;
    bool vis[maxn];
    int level[maxn];
    int st, ed,needflow;

    void Init(int nodes,int source,int dest)
    {
        n = nodes, st = source, ed = dest;
        memset(Head, -1, sizeof(Head));
        totedge = 0;
    }

    void addedge(int from, int to, int cap)
    {
        Edge[totedge] = edge(from, to, cap, 0, Head[from]);
        Head[from] = totedge++;
        Edge[totedge] = edge(to, from, 0, 0, Head[to]);
        Head[to] = totedge++;
    }

    bool Dicnic_bfs()
    {
        queue<int>q;
        int i, u, v;
        memset(level, -1, sizeof(level));
        memset(vis, 0, sizeof(vis));

        q.push(st);
        level[st] = 0;
        vis[st] = true;
        while (!q.empty())
        {
            u = q.front();
            q.pop();

            if (u == ed) return true;
            for (int i = Head[u]; i != -1; i = Edge[i].next)
            {
                v = Edge[i].to;
                if (Edge[i].cap > Edge[i].flow && !vis[v] && level[v] == -1)
                {
                    vis[v] = true;
                    level[v] = level[u] + 1;
                    q.push(v);
                }
            }
        }
        return false;
    }

    int Dicnic_dfs(int u, int maxf)
    {
        if (u == ed || maxf == 0) return maxf;

        int flow = 0, f;
        for (int &i = tmp_head[u]; i != -1; i = Edge[i].next)
        {
            int v = Edge[i].to;
            if (Edge[i].cap - Edge[i].flow > 0 && level[v] == level[u] + 1)
            {
                f = Dicnic_dfs(v, min(maxf, Edge[i].cap - Edge[i].flow));
                if (f > 0)
                {
                    Edge[i].flow += f;
                    Edge[i ^ 1].flow -= f;
                    flow += f;
                    maxf -= f;
                    //if (maxf == 0) break;
                    //if (flow >= needflow) return flow;
                    break;
                }
            }
        }
        if (flow == 0) level[u] = -1;
        return flow;
    }

    int Dicnic_maxflow(int ndflow=INF)
    {
        int ret = 0;
        needflow = ndflow;
        while (Dicnic_bfs())
        {
            memcpy(tmp_head, Head, sizeof(Head));
            ret += Dicnic_dfs(st, INF);
            //ret += Dicnic_dfs(st, needlow-ret);
            if (ret >= needflow) return ret;
        }
        return ret;
    }

    void set(int nodes,int source, int dest)
    {
        n=nodes,st = source, ed = dest;
    }
}dnc;

int N, M, K, S, T;
const int maxm = 210;
struct tunnel
{
    int from, to;
}tnl[maxm];
const int maxk = 110;
int prepos[maxk], ismove[maxk], ss[maxk], tt[maxk];
//prepos[i]表示第i个飞船上一次停留的位置
//ismove[i]表示第i个飞船当天是否已经飞过（从一个星球飞到另一个星球耗时一天）
//ss[i],tt[j] 表示当天存在从ss[i]到tt[j]的飞行

bool Cmp(const pair<int, int>&a, const pair<int, int>&b)
{
    return a.first < b.first;
}
int main()
{
    while (~scanf("%d%d%d%d%d", &N, &M, &K, &S, &T))
    {

        dnc.Init(N, S, T);
        for (int i = 1; i <=M; i++)
        {
            scanf("%d%d", &tnl[i].from, &tnl[i].to);
        }
        //每多加一天新增边
        int sum = 0, day = 0;
        while (sum < K)
        {
            day++;
            for (int i = 1; i <= N; i++) dnc.addedge((day - 1)*N + i, day*N + i, INF);
            for (int i = 1; i <= M; i++)
            {
                dnc.addedge((day - 1)*N + tnl[i].from, day*N + tnl[i].to, 1);
                dnc.addedge((day - 1)*N + tnl[i].to, day*N + tnl[i].from, 1);
            }
            dnc.set(N+day*N,S, T + day*N);
            sum += dnc.Dicnic_maxflow(K - sum);
        }
        //输出答案
        printf("%d
", day);
        for (int i = 1; i <= K; i++) prepos[i] = S;
        int id = 0;
        for (int d = 1; d <= day; d++)
        {
            id += N*2;//跳过载有计算机的飞船停留在某个星球上一天的边
            int cnt = 0;//记录当天的所有飞行次数
            for (int i = 1; i <= M; i++)
            {
                int flow1 = Edge[id].flow;//从(day - 1)*N + tnl[i].from到day*N + tnl[i].to
                id += 2;
                int flow2 = Edge[id].flow;//从(day - 1)*N + tnl[i].to到day*N + tnl[i].from
                id += 2;
                //flow1和flow2不能同时有流量.如果同时有，说明两艘飞船互换位置，但对总体的进度没有影响
                if (flow1 && !flow2) ss[cnt] = tnl[i].from, tt[cnt++] = tnl[i].to;
                if (flow2 && !flow1) ss[cnt] = tnl[i].to, tt[cnt++] = tnl[i].from;
            }
            memset(ismove, 0, sizeof(ismove));
            printf("%d", cnt);
            vector<pair<int, int> >fly;
            for (int i = 0; i < cnt; i++)//对每一个飞行次数，分配给符合条件的飞船
            {
                for (int j = 1; j <= K; j++)
                {
                    if (ss[i] == prepos[j] && !ismove[j])
                    {
                        fly.push_back(make_pair(j, tt[i]));
                        //printf(" %d %d", j, tt[i]);
                        prepos[j] = tt[i];
                        ismove[j] = true;
                        break;
                    }
                }
            }
            sort(fly.begin(), fly.end(), Cmp);
            for (int i = 0; i < cnt; i++)
            {
                printf(" %d %d", fly[i].first, fly[i].second);
            }
            printf("
");
        }
    }
    return 0;
}

 10、uvalive 2531 The K-League UVALive

　　题意：有n个球队，现在每支球队已经赢了Wi场，输了Di场，并给出两两之间剩余的比赛数，问最后可能胜利的队伍有哪些？

　　思路：首先假设第i个球队剩下的场数全部胜利，则totwin=Wi+sum(…)，那么我们建立一个超级源点和一个超级汇点，从超级源点连到每个匹配（k,j）,容量为其剩余的场数，并记录总剩余场数tot,而每个匹配可以是k胜利或者j胜利，所以连边，容量为INF；然后因为要确保其他队伍j胜利的总场数不超过球队i能够达到的最大胜利场数totwin,则每只球队j连到超级汇点，容量为其所能够胜利的最大场数，即totwin-Wj.最后求最大流，如果最大流刚好等于总剩余场数，说明在所有剩余场数比完之后，球队i可能获胜。

#include<iostream>
#include<algorithm>
#include<queue>
#include<cstring>
#include<vector>
#include<cstdio>
using namespace std;
const int maxn = 1010;
const int maxe = maxn * 2;
const int INF = 0x3f3f3f3f;
struct edge
{
    int from, to, cap, flow, next;
    edge(int ff=0,int tt=0,int cc=0,int ww=0,int nn=0):from(ff),to(tt),cap(cc),flow(ww),next(nn){ }
}Edge[maxe];
int Head[maxn], tmp_Head[maxn], totedge;

struct Dicnic
{
    int n,st,ed,needflow;
    int level[maxn];
    int vis[maxn];

    void Init()
    {
        memset(Head, -1, sizeof(Head));
        totedge = 0;
    }

    void Set(int nodes, int source, int dest)
    {
        n = nodes, st = source, ed = dest;
    }

    void addedge(int from, int to, int cap)
    {
        Edge[totedge] = edge(from, to, cap, 0, Head[from]);
        Head[from] = totedge++;
        Edge[totedge] = edge(to, from, 0, 0, Head[to]);
        Head[to] = totedge++;
    }

    bool Dicnic_bfs()
    {
        queue<int>q;
        int i, u, v;
        memset(level, -1, sizeof(level));
        memset(vis, 0, sizeof(vis));

        q.push(st);
        vis[st] = true;
        level[st] = 0;
        while (!q.empty())
        {
            u = q.front();
            q.pop();
            if (u == ed) return true;

            for (int i = Head[u]; i != -1; i = Edge[i].next)
            {
                v = Edge[i].to;
                if (Edge[i].cap > Edge[i].flow && !vis[v] && level[v] == -1)
                {
                    vis[v] = true;
                    level[v] = level[u] + 1;
                    q.push(v);
                }
            }
        }
        return false;
    }

    int Dicnic_dfs(int u, int maxf)
    {
        if (u == ed || maxf == 0) return maxf;

        int flow = 0, f;
        for (int &i = tmp_Head[u]; i != -1; i = Edge[i].next)
        {
            int v = Edge[i].to;
            if (Edge[i].cap > Edge[i].flow&&level[v] == level[u] + 1)
            {
                f = Dicnic_dfs(v, min(maxf, Edge[i].cap - Edge[i].flow));
                if (f > 0)
                {
                    Edge[i].flow += f;
                    Edge[i ^ 1].flow -= f;
                    flow += f;
                    maxf -= f;
                    if (maxf == 0) break;
                    if (flow >= needflow) return flow;
                }
            }
        }
        return flow;
     }

    int Dicnic_maxflow(int ndflow = INF)
    {
        int ret = 0;
        needflow = ndflow;
        while (Dicnic_bfs())
        {
            memcpy(tmp_Head, Head, sizeof(Head));
            ret += Dicnic_dfs(st, needflow);
            if (ret >= needflow) return ret;
        }
        return ret;
    }
}dnc;

int win[30], lost[30], remain[30][30];
vector<int>canwin;
int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        int n;
        scanf("%d", &n);
        for (int i = 1; i <= n; i++) scanf("%d%d", &win[i], &lost[i]);
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= n; j++) scanf("%d", &remain[i][j]);
        }

        canwin.clear();
        for (int i = 1; i <= n; i++)
        {
            int totwin = win[i];
            for (int j = 1; j <= n; j++) totwin += remain[i][j];
            bool ok = true;
            for (int j = 1; j <= n; j++)
            {
                if (j != i&&win[j] > totwin)
                {
                    ok = false;
                    break;
                }
            }
            if (!ok) continue;

            dnc.Init();
            dnc.Set(n*n + n + 2, 0, n*n + n + 1);
            int full = 0;
            for (int k = 1; k <= n; k++)
            {
                for (int j = k + 1; j <= n; j++)
                {
                    full += remain[k][j];
                    if (remain[k][j] > 0) dnc.addedge(0, k*n + j, remain[k][j]);
                    dnc.addedge(k*n + j, n*n + k, INF);
                    dnc.addedge(k*n + j, n*n + j, INF);
                }
                if (totwin > win[k]) dnc.addedge(n*n + k, n*n + n + 1, totwin-win[k]);
            }
            int flow = dnc.Dicnic_maxflow();
            if (flow == full) canwin.push_back(i);
        }
        int sz = canwin.size();
        for (int i = 0; i < sz; i++)
        {
            if (i) printf(" ");
            printf("%d", canwin[i]);
        }
        printf("
");
    }
    return 0;
}

 11、uva 10779 Collectors Problem

　　题意：Bob有n-1个朋友，每个人有Ki张贴纸，贴纸的类型一共有m种。现在，Bob的朋友只会和Bob交换自己没有的贴纸，问Bob最后得到贴纸的种类最大是多少？

　　思路：Bob作为源点，对已经有的贴纸类型建边，容量为其所拥有的该类型的贴纸的数目；每种类型的贴纸向汇点建边，容量为1，表示能否得到该类型的贴纸；当某个朋友拥有某种类型的贴纸的数目大于1时，其可以拿出数目-1这么多的该类型贴纸来交换，则该朋友向该类型贴纸建边，容量为对应数目-1；如果朋友没有某种类型的贴纸，则Bob可以和其交换1张，则该贴纸类型向朋友建边，容量为1.最后用Dicnic求最大流即可。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<vector>
using namespace std;
const int maxn = 110;
const int INF = 0x3f3f3f3f;
const int maxe = 510;
struct edge
{
    int from, to, cap, flow, next;
    edge(int ff=0,int tt=0,int cc=0,int ww=0,int nn=0):from(ff),to(tt),cap(cc),flow(ww),next(nn){ }
}Edge[maxe];
int Head[maxn], tmp_head[maxn],totedge;

struct Dicnic
{
    int n, needflow, st, ed;
    int level[maxn];
    bool vis[maxn];

    void Init()
    {
        memset(Head, -1, sizeof(Head));
        totedge = 0;
    }

    void set(int nodes, int source, int dest)
    {
        n = nodes, st = source, ed = dest;
    }
    
    void addedge(int from, int to, int cap)
    {
        Edge[totedge] = edge(from, to, cap, 0, Head[from]);
        Head[from] = totedge++;
        Edge[totedge] = edge(to, from, 0, 0, Head[to]);
        Head[to] = totedge++;
    }

    bool Dicnic_bfs()
    {
        memset(level, -1, sizeof(level));
        memset(vis, 0, sizeof(vis));

        queue<int>q;
        q.push(st);
        vis[st] = true;
        level[st] = 0;

        while (!q.empty())
        {
            int u = q.front();
            q.pop();

            if (u == ed) return true;
            for (int i = Head[u]; i != -1; i = Edge[i].next)
            {
                int v = Edge[i].to;
                if (!vis[v] && Edge[i].cap > Edge[i].flow)
                {
                    vis[v] = true;
                    level[v] = level[u] + 1;
                    q.push(v);
                }
            }
        }
        return false;
    }

    int Dicnic_dfs(int u, int maxf)
    {
        if (u == ed || maxf == 0) return maxf;
        
        int flow = 0, f;
        for (int& i = tmp_head[u]; i != -1; i = Edge[i].next)
        {
            int v = Edge[i].to;
            if (Edge[i].cap > Edge[i].flow&&level[v] == level[u] + 1)
            {
                f = Dicnic_dfs(v, min(maxf, Edge[i].cap - Edge[i].flow));
                if (f>0)
                {
                    Edge[i].flow += f;
                    Edge[i ^ 1].flow -= f;
                    flow += f;
                    maxf -= f;
                    if (maxf <= 0) break;
                    if (flow >= needflow) return flow;
                }
            }
        }
        return flow;
    }

    int Dicnic_maxflow(int ndflow=INF)
    {
        int ret = 0;
        needflow = ndflow;
        while (Dicnic_bfs())
        {
            memcpy(tmp_head, Head, sizeof(Head));
            ret += Dicnic_dfs(st, needflow);
            if (ret >= needflow) return ret;
        }
        return ret;
    }


}dnc;

int cnt[15][30];
int main()
{
    int t;
    scanf("%d", &t);
    int Case = 1;
    while (t--)
    {
        int n,m;
        scanf("%d%d", &n,&m);
        //Bob为1，朋友为2~n,类型为n+1~n+m,汇点为n+m+1
        dnc.Init();
        dnc.set(n + m + 1, 1, n + m + 1);
        memset(cnt, 0, sizeof(cnt));
        for (int i = 1; i <= n; i++)
        {
            int k;
            scanf("%d", &k);
            for (int j = 1; j <= k; j++)
            {
                int v;
                scanf("%d", &v);
                cnt[i][v]++;
            }
        }
        for (int i = 1; i <= m; i++)
        {
            if (cnt[1][i]) dnc.addedge(1, n + i, cnt[1][i]);
            dnc.addedge(n + i, n + m + 1, 1);
        }
        for (int i = 2; i <= n; i++)
        {
            for (int j = 1; j <= m; j++)
            {
                if (cnt[i][j] > 1) dnc.addedge(i, n + j, cnt[i][j] - 1);
                else if (cnt[i][j] == 0) dnc.addedge(n + j, i, 1);
            }
        }
        int flow = dnc.Dicnic_maxflow();
        printf("Case #%d: %d
",Case++, flow);
    }
    return 0;
}

 12、uvalive 3286 Jamie's Contact Groups

　　题意：有n个人，有m个组别，每个人选择一些组别加入，但只能加入其中的一个。问，所有人分组后，人数最多的组别的人数最小是多少？

　　思路：设置源点连向每一个人，权值为1，表示每个人都可以选择加入一个组别；每个人连向其所能加入的组别，权值为1；之后二分最大组别的人数，设其为tmpmax,从每个组别连向汇点，表示最多只能选择tmpmax这么多的人加入，然后求最大流，当==n时看看能不能让tmpmax减少。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#include<string>
#include<sstream>
using namespace std;
const int maxn = 2100;
const int INF = 0x3f3f3f3f;
const int maxe = 2 * 1000 + 1000 * 500*2 + 500*2 + 10;
struct edge
{
    int from, to, cap, flow, next;
    edge(int ff=0,int tt=0,int cc=0,int ww=0,int nn=0):from(ff),to(tt),cap(cc),flow(ww),next(nn){ }
}Edge[maxe];
int Head[maxn], tmp_head[maxn],totedge;

struct Dicnic
{
    int n, st, ed, needflow;
    int level[maxn];
    int vis[maxn];

    void Init()
    {
        memset(Head, -1, sizeof(Head));
        totedge = 0;
    }

    void set(int nodes, int source, int dest)
    {
        n = nodes, st = source, ed = dest;
    }

    void addedge(int from, int to, int cap)
    {
        Edge[totedge] = edge(from, to, cap, 0, Head[from]);
        Head[from] = totedge++;
        Edge[totedge] = edge(to, from, 0, 0, Head[to]);
        Head[to] = totedge++;
    }

    bool Dicnic_bfs()
    {
        memset(level, -1, sizeof(level));
        memset(vis, 0, sizeof(vis));

        queue<int>q;
        q.push(st);
        vis[st] = true;
        level[st] = 0;
        while (!q.empty())
        {
            int u = q.front();
            q.pop();

            if (u == ed) return true;
            for (int i = Head[u]; i != -1; i = Edge[i].next)
            {
                int v = Edge[i].to;
                if (Edge[i].cap > Edge[i].flow && !vis[v])
                {
                    vis[v] = true;
                    level[v] = level[u] + 1;
                    q.push(v);
                }
            }
        }
        return false;
    }

    int Dicnic_dfs(int u, int maxf)
    {
        if (u == ed || maxf == 0) return maxf;
        
        int flow = 0, f;
        for (int &i = tmp_head[u]; i != -1; i = Edge[i].next)
        {
            if (Edge[i].cap > Edge[i].flow&&level[Edge[i].to] == level[u] + 1)
            {
                int f = Dicnic_dfs(Edge[i].to, min(maxf, Edge[i].cap - Edge[i].flow));
                if (f > 0)
                {
                    Edge[i].flow += f;
                    Edge[i ^ 1].flow -= f;
                    flow += f;
                    maxf -= f;
                    if (maxf <= 0) break;
                }
            }
        }
        return flow;
    }

    int cal_maxflow()
    {
        int ret = 0;
        while (Dicnic_bfs())
        {
            memcpy(tmp_head, Head, sizeof(Head));
            ret += Dicnic_dfs(st, INF);
        }
        return ret;
    }

    void clearflow()
    {
        for (int i = 0; i < totedge; i++) Edge[i].flow = 0;
    }
}dnc;
int n, m;
char name[20];
string putin;
int main()
{
    while (~scanf("%d%d", &n, &m) && n + m)
    {
        dnc.Init();
        //组别为0-m-1,源点为m,人为m+1-m+n,汇点为m+n+1
        dnc.set(n + m + 2, m, m + n + 1);
        for (int i = 1; i <= n; i++)
        {
            dnc.addedge(m, m + i, 1);
        }
        getline(cin, putin);
        for (int i = 1; i <= n; i++)
        {
            getline(cin, putin);
            stringstream ssin(putin);
            ssin >> name;
            int id=0;
            while (ssin>>id)
            {
                dnc.addedge(m + i, id, 1);
            }
        }
        int nowedge =totedge;
        int ans = m;
        int l = 1,r = n;
        while (l<=r)
        {
            dnc.clearflow();
            int curmax = (l + r) / 2;
            if (totedge == nowedge)
            {
                for (int i = 0; i < m; i++)
                {
                    dnc.addedge(i, n + m + 1, curmax);
                }
            }
            else
            {
                for (int i = nowedge; i < totedge; i +=2) Edge[i].cap = curmax;
            }
            int tans = dnc.cal_maxflow();
            if (tans == n)
            {
                ans = curmax;
                r = curmax - 1;
            }
            else if (tans < n) l = curmax + 1;
        }
        printf("%d
", ans);
    }
    return 0;
}

 13、uva 11082 Matrix Decompressing

　　题意：有R*C的矩阵，已知前i行元素和前j列元素的和，当矩阵元素在1~20之间时，求满足条件的一个矩阵。

　　思路：因为限制矩阵元素的大小，所以当行连向列时，假设每条边已经至少为1，那么边权可以设为19，然后输出时+1即可。然后从源点连向行i,边权为SUMRi-C;从列连向汇点，边权为SUMCi-R.Dicnic求最大流即可。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cstdio>
using namespace std;
const int maxn = 50;
const int maxe = 20 * 2 * 2 + 20 * 20 * 2 + 10;
const int INF = 0x3f3f3f3f;
struct edge
{
    int from, to, cap, flow, next;
    edge(int ff=0,int tt=0,int cc=0,int ww=0,int nn=0):from(ff),to(tt),cap(cc),flow(ww),next(nn){ }
}Edge[maxe];
int Head[maxn], totedge, tmp_head[maxn];

struct Dicnic
{
    int n, st, ed;
    int level[maxn];
    int vis[maxn];

    void Init()
    {
        memset(Head, -1, sizeof(Head));
        totedge = 0;
    }
    void set(int nodes, int source, int dest)
    {
        n = nodes, st = source, ed = dest;
    }
    void addedge(int from, int to, int cap)
    {
        Edge[totedge] = edge(from, to, cap, 0, Head[from]);
        Head[from] = totedge++;
        Edge[totedge] = edge(to, from, 0, 0, Head[to]);
        Head[to] = totedge++;
    }
    bool Dicnic_bfs()
    {
        memset(level, -1, sizeof(level));
        memset(vis, 0, sizeof(vis));

        queue<int>q;
        q.push(st);
        vis[st] = true;
        level[st] = 0;
        while (!q.empty())
        {
            int u = q.front();
            q.pop();
            if (u == ed) return true;
            for (int i = Head[u]; i != -1; i = Edge[i].next)
            {
                int v = Edge[i].to;
                if (Edge[i].cap > Edge[i].flow && level[v]==-1&&!vis[v])
                {
                    vis[v] = true;
                    level[v] = level[u] + 1;
                    q.push(v);
                }
            }
        }
        return false;
    }

    int Dicnic_dfs(int u, int maxf)
    {
        if (u == ed || maxf == 0) return maxf;

        int flow = 0, f;
        for (int&i = tmp_head[u]; i != -1; i = Edge[i].next)
        {
            int v = Edge[i].to;
            if (Edge[i].cap > Edge[i].flow&&level[v] == level[u] + 1)
            {
                f = Dicnic_dfs(v, min(maxf, Edge[i].cap - Edge[i].flow));
                if (f > 0)
                {
                    Edge[i].flow += f;
                    Edge[i ^ 1].flow -= f;
                    flow += f;
                    maxf -= f;
                    if (maxf == 0) break;
                }
            }
        }
        return flow;
    }

    int cal_maxflow()
    {
        int ret = 0;
        while (Dicnic_bfs())
        {
            memcpy(tmp_head, Head, sizeof(Head));
            ret += Dicnic_dfs(st, INF);
        }
        return ret;
    }
}dnc;
int sumr[30], sumc[30];
int main()
{
    int t, Case = 1;
    scanf("%d", &t);
    int R, C;
    while (t--)
    {
        scanf("%d%d", &R, &C);
        for (int i = 1; i <= R; i++)
        {
            scanf("%d",&sumr[i]);
        }
        int sum = sumr[R];
        for (int i = R; i>1; i--)
        {
            sumr[i] -= sumr[i - 1];
        }
        for (int i = 1; i <= C; i++)
        {
            scanf("%d", &sumc[i]);
        }
        for (int i = C; i>1; i--)
        {
            sumc[i] -= sumc[i - 1];
        }
        //起点为0，行从1-R，列从R+1-R+C,汇点为R+C+1
        dnc.Init();
        dnc.set(R + C + 2, 0, R + C + 1);
        for (int i = 1; i <= R; i++) dnc.addedge(0, i, sumr[i]-C);
        for (int i = 1; i <= C; i++) dnc.addedge(R + i, R + C + 1, sumc[i]-R);
        int nowedge = totedge;
        for (int i = 1; i <= R; i++)
        {
            for (int j = 1; j <= C; j++)
            {
                dnc.addedge(i, R + j, 19);
            }
        }
        dnc.cal_maxflow();
        nowedge -= 2;
        printf("Matrix %d
", Case++);
        for (int i = 1; i <=R; i++)
        {
            for (int j = 1; j <= C; j++)
            {
                nowedge += 2;
                printf("%d ", Edge[nowedge].flow + 1);
            }
            printf("
");
        }
        if(t) printf("
");
    }
    return 0;
}

 14、uvalive 3645 Objective  Berlin

　　题意：有若干座城市，他们之间有n条航线，每条航线的信息包括起始点、终点、起始时间、到达时间、乘客人数。当到达一座城市后，想要乘另一条航线离开至少要过30分钟。问在截止时间前从给定的一个城市前往给定的另一个城市的最大乘客数目。

　　思路：将每条航线i拆成两个点2*i-1和2*i,前者表示从该航线起点站离开，后者表示从该航线终点站到达，前者向后者建边，容量为乘客数目；如果某条航线的起点站为给定的出发城市，则从汇点向其起点站建边，容量为INF；如果某条航线的终点站为给定的前往城市，则从其终点站向汇点建边，容量为INF；如果某条航线到达后至少过30分钟后能够乘另一条航线离开，则前者的终点站向后者的起点站建边，容量为INF。Dicnic求最大流即可。注意建边时航线的到达时间不应该迟于截止时间。

#include<iostream>
#include<cstring>
#include<queue>
#include<map>
#include<string>
using namespace std;
const int maxn = 5000 * 2 + 10;
const int maxe = 5000 * 2 + 5000 * 2 + 5000 * 5000 + 5000 * 2 + 5000 * 2 + 100;
const int INF = 0x3f3f3f3f;
struct edge
{
    int from, to, cap, flow, next;
    edge(int ff=0,int tt=0,int cc=0,int ww=0,int nn=0):from(ff),to(tt),cap(cc),flow(ww),next(nn){ }
}Edge[maxe];
int Head[maxn], tmp_head[maxn], totedge;
struct dicnic
{
    int n, st, ed;
    int level[maxn];
    bool vis[maxn];

    void Init()
    {
        memset(Head, -1, sizeof(Head));
        totedge = 0;
    }
    void set(int nodes, int source, int dest)
    {
        n = nodes, st = source, ed = dest;
    }
    void addedge(int from, int to, int cap)
    {
        Edge[totedge] = edge(from, to, cap, 0, Head[from]);
        Head[from] = totedge++;
        Edge[totedge] = edge(to, from, 0, 0, Head[to]);
        Head[to] = totedge++;
    }
    bool dicnic_bfs()
    {
        memset(level, -1, sizeof(level));
        memset(vis, 0, sizeof(vis));
        queue<int>q;
        q.push(st);
        vis[st] = true;
        level[st] = 0;
        while (!q.empty())
        {
            int u = q.front();
            q.pop();
            if (u == ed) return true;
            for (int i = Head[u]; i != -1; i = Edge[i].next)
            {
                int v = Edge[i].to;
                if (Edge[i].cap > Edge[i].flow && !vis[v])
                {
                    vis[v] = true;
                    level[v] = level[u] + 1;
                    q.push(v);
                }
            }
        }
        return false;
    }

    int dicnic_dfs(int u, int maxf)
    {
        if (u == ed || maxf == 0) return maxf;

        int flow = 0, f;
        for (int &i = tmp_head[u]; i != -1; i = Edge[i].next)
        {
            int v = Edge[i].to;
            if (Edge[i].cap > Edge[i].flow&&level[v] == level[u] + 1)
            {
                f = dicnic_dfs(v, min(maxf, Edge[i].cap - Edge[i].flow));
                if (f > 0)
                {
                    Edge[i].flow += f;
                    Edge[i ^ 1].flow -= f;
                    flow += f;
                    maxf -= f;
                    if (maxf == 0) break;
                }
            }
        }
        return flow;
    }

    int dicnic_maxflow()
    {
        int ret = 0;
        while (dicnic_bfs())
        {
            memcpy(tmp_head, Head, sizeof(Head));
            ret += dicnic_dfs(st, INF);
        }
        return ret;
    }
}dnc;
int cities;
map<string, int>mp;
char name[15];
char stname[15], edname[15];
struct fly
{
    int fromid, toid;
    int cap;
    int sttime, edtime;
}flight[maxn>>1];
int main()
{
    while (~scanf("%d", &cities))
    {
        mp.clear();
        scanf("%s", name);
        mp[name] = 1;
        scanf("%s", name);
        mp[name] = cities;
        int curcityid = 2;
        int edtime, m;
        scanf("%d%d", &edtime, &m);
        dnc.Init();
        dnc.set(m*2 + 2, 0, m*2 + 1);
        for (int i = 1; i <= m; i++)
        {
            scanf("%s%s", stname, edname);
            if (!mp[stname]) mp[stname] = curcityid++;
            if (!mp[edname]) mp[edname] = curcityid++;
            flight[i].fromid = mp[stname], flight[i].toid = mp[edname];
            scanf("%d%d%d", &flight[i].cap, &flight[i].sttime, &flight[i].edtime);
            if (flight[i].fromid == 1) dnc.addedge(0, i * 2 - 1, INF);
            if (flight[i].toid == cities&&flight[i].edtime<=edtime) dnc.addedge(i * 2, m * 2 + 1, INF);
            dnc.addedge(i * 2 - 1, i * 2, flight[i].cap);
        }
        for(int i=1;i<=m;i++)
        {
            if (flight[i].edtime > edtime)continue;
            for (int j = 1; j <=m; j++)
            {
                if (i == j) continue;
                if (flight[i].toid == flight[j].fromid&&(flight[j].sttime/100*60+ flight[j].sttime%100)-(flight[i].edtime/100*60+ flight[i].edtime%100)>=30&&flight[j].edtime<=edtime)
                {
                    dnc.addedge(i * 2, j * 2 - 1, INF);
                }
            }
        }
        int ans = dnc.dicnic_maxflow();
        printf("%d
", ans);
    }
    return 0;
}

 15、uvalive 4597/uva 1440 Inspection

　　题意：有一座山上修建了许多滑雪的通道，有n个点构成有向无环图。现在你可以任意从一个起点出发，到达另一个可以到达的点，记为一条路径。求用最少的路径，保证每条边都至少走过一次。

　　思路：有下限的最小流。首先选择出度大于入度的点作为起点，入度大于出度的点作为终点。然后因为每条边可以走多次。那么如果想要走过所有的边，则至多有sum（abs(入度-出度)）条路径。出度大于入度的点连向汇点，源点连向入度大于出度的点，其最大流为可以减少的路径数，并且可以得到每条正向边所要多走的次数（即其flow值）,该值需要累加至入度或出度（表示可以多走）。然后用dfs,当出度-入度>0时，表示能够扩展出一条路径，dfs深搜可以走的点，并且修改入度和出度。这里可以用一个数组记录入度-出度的数值，以方便运算。

参考博客：https://www.cnblogs.com/dwtfukgv/p/7780903.html、http://blog.csdn.net/fuxey/article/details/50472528、http://blog.csdn.net/sdj222555/article/details/40380423

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;


const int maxn = 210;
const int maxe = 100 * 100 * 2 + 100 * 4 + 100;
const int INF = 0x3f3f3f3f;
int dindgree[maxn], n;//dindgree[i]存的是i结点入度减去出度的值
vector<int>result;
struct edge
{
    int from, to, cap, flow, next;
    edge(int ff=0,int tt=0,int cc=0,int ww=0,int nn=0):from(ff),to(tt),cap(cc),flow(ww),next(nn){ }
}Edge[maxe];
int Head[maxn], tmp_head[maxn], totedge;
struct dicnic
{
    int n, st, ed;
    int level[maxn];
    bool vis[maxn];

    void Init()
    {
        memset(Head, -1, sizeof(Head));
        totedge = 0;
    }
    void set(int nodes, int source, int dest)
    {
        n = nodes, st = source, ed = dest;
    }
    void addedge(int from, int to, int cap)
    {
        Edge[totedge] = edge(from, to, cap, 0, Head[from]);
        Head[from] = totedge++;
        Edge[totedge] = edge(to, from, 0, 0, Head[to]);
        Head[to] = totedge++;
    }
    bool dicnic_bfs()
    {
        memset(level, -1, sizeof(level));
        memset(vis, 0, sizeof(vis));
        queue<int>q;
        q.push(st);
        vis[st] = true;
        level[st] = 0;
        while (!q.empty())
        {
            int u = q.front();
            q.pop();
            if (u == ed) return true;
            for (int i = Head[u]; i != -1; i = Edge[i].next)
            {
                int v = Edge[i].to;
                if (Edge[i].cap > Edge[i].flow && !vis[v])
                {
                    vis[v] = true;
                    level[v] = level[u] + 1;
                    q.push(v);
                }
            }
        }
        return false;
    }
    int dicnic_dfs(int u, int maxf)
    {
        if (u == ed || maxf == 0) return maxf;

        int flow = 0, f;
        for (int &i = tmp_head[u]; i != -1; i = Edge[i].next)
        {
            int v = Edge[i].to;
            if (Edge[i].cap > Edge[i].flow&&level[v] == level[u] + 1)
            {
                int f = dicnic_dfs(v, min(maxf, Edge[i].cap - Edge[i].flow));
                if (f > 0)
                {
                    Edge[i].flow += f;
                    if(Edge[i].cap>0) dindgree[v] += f;//默认每条边走过一次，流为0.所增加的流表示重复多走过的次数
                    Edge[i ^ 1].flow -= f;
                    flow += f;
                    maxf -= f;
                    if (maxf == 0) break;
                }
            }
        }
        return flow;
    }

    int cal_maxflow()
    {
        int ret = 0;
        while (dicnic_bfs())
        {
            memcpy(tmp_head, Head, sizeof(Head));
            ret += dicnic_dfs(st, INF);
        }
        return ret;
    }
}dnc;



int main()
{
    while (~scanf("%d", &n)&&n)
    {
        dnc.Init();
        dnc.set(n + 2, 0, n + 1);
        memset(dindgree, 0, sizeof(dindgree));
        for (int i = 1; i <= n; i++)
        {
            int k;
            scanf("%d", &k);
            dindgree[i] -= k;
            for (int j = 1; j <= k; j++)
            {
                int to;
                scanf("%d", &to);
                dnc.addedge(i, to, INF);//每条边可以走多次，所以容量为INF
                dindgree[to]++;
            }
        }
        int nowedge = totedge;
        int ans = 0;//ans的值就是正向最大流
        for (int i = 1; i <= n; i++)
        {
            /*逆向建边。原本正向应该是源点连向出度大于入度的点，入度大于出度的点连向汇点。
            逆向则是出度大于入度的点连向汇点，源点连向入度大于出度的点。*/
            if (dindgree[i]<0) dnc.addedge(i,n+1, -dindgree[i]),ans+= - dindgree[i];
            if (dindgree[i] >0) dnc.addedge(0,i, dindgree[i]);
        }
        ans -= dnc.cal_maxflow();//减去逆向最大流
        printf("%d
", ans);

        
        for (int i = 1; i <= n; i++)
        {
            while (dindgree[i] < 0)
            {//表示还能将点i作为某一条路线的起点（出度大）
                dindgree[i]++;//修改所还能作为起点的次数
                result.clear();//result记录该条路线
                result.push_back(i);
                int u = i;
                while (1)
                {
                    bool ok = false;//表示能否从该点走向其他点
                    for (int i = Head[u]; i != -1; i = Edge[i].next)
                    {
                        ////默认每条边走过一次，流为0.所以如果流为1，表示不能再走这条边。所选择的边应当为正向边，且没有和自设的源点或汇点相连
                        if (Edge[i].flow == -1 || Edge[i].cap == 0 || Edge[i].to == n + 1 || Edge[i].to == 0)continue;
                        
                        ok = true;
                        Edge[i].flow--;
                        u = Edge[i].to;
                        result.push_back(u);
                        break;
                    }
                    if (!ok) break;//不能继续走，退出打印路径
                }
                int sz = result.size();
                for (int i = 0; i < sz; i++)
                {
                    if (i) printf(" ");
                    printf("%d", result[i]);
                }
                printf("
");
            }
        }
    }
    return 0;
}

 16、uvalive 3487 Duopoly

　　题意：有两家公司分别对拍卖会上的channel进行竞价，分别给出每一组的给出价格和该组所包含的channel（表示用这么多的钱购买该组所有的channel）。但是对于两家公司矛盾的bid,只能选择接受其中一家的竞价，即每一个channel只能被一家公司拥有，求拍卖所得最大利润？

　　思路：如果两家没有矛盾的地方，则最大利润则是格子出价之和。如果有矛盾，则肯定选取利润高的，扔掉代价小的。将有矛盾的两家的bid相连，之后求最大流，最后得到最大流的值为所要扔掉的所有的代价。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<vector>
#include<string>
#include<sstream>
using namespace std;
const int maxn = 6100;
const int INF = 0x3f3f3f3f;
struct edge
{
    int from, to, cap, flow, next;
    edge(int ff = 0, int tt = 0, int cc = 0, int ww = 0, int nn = 0) :from(ff), to(tt), cap(cc), flow(ww), next(nn)
    {
    }
};
vector<edge>Edge;
int Head[maxn], tmp_head[maxn], totedge;

struct dicnic
{
    int n, st, ed;
    int level[maxn];
    bool vis[maxn];
    void Init()
    {
        memset(Head, -1, sizeof(Head));
        totedge = 0;
        Edge.clear();
    }
    void set(int nodes, int source, int dest)
    {
        n = nodes, st = source, ed = dest;
    }
    void addedge(int from, int to, int cap)
    {
        Edge.push_back(edge(from, to, cap, 0, Head[from]));
        Head[from] = totedge++;
        Edge.push_back(edge(to, from, 0, 0, Head[to]));
        Head[to] = totedge++;
    }
    bool dicnic_bfs()
    {
        memset(level, -1, sizeof(level));
        memset(vis, 0, sizeof(vis));
        queue<int>q;
        q.push(st);
        vis[st] = true;
        level[st] = 0;
        while (!q.empty())
        {
            int u = q.front();
            q.pop();
            if (u == ed) return true;
            for (int i = Head[u]; i != -1; i = Edge[i].next)
            {
                int v = Edge[i].to;
                if (Edge[i].cap > Edge[i].flow && !vis[v])
                {
                    vis[v] = true;
                    level[v] = level[u] + 1;
                    q.push(v);
                }
            }
        }
        return false;
    }

    int dicnic_dfs(int u, int maxf)
    {
        if (u == ed || maxf == 0) return maxf;

        int flow = 0, f;
        for (int &i = tmp_head[u]; i != -1; i = Edge[i].next)
        {
            int v = Edge[i].to;
            if (Edge[i].cap > Edge[i].flow&&level[v] == level[u] + 1)
            {
                f = dicnic_dfs(v, min(maxf, Edge[i].cap - Edge[i].flow));
                if (f > 0)
                {
                    Edge[i].flow += f;
                    Edge[i ^ 1].flow -= f;
                    flow += f;
                    maxf -= f;
                    if (maxf == 0) break;
                }
            }
        }
        return flow;
    }
    int cal_maxflow()
    {
        int ret = 0;
        while (dicnic_bfs())
        {
            memcpy(tmp_head, Head, sizeof(Head));
            ret += dicnic_dfs(st, INF);
        }
        return ret;
    }
}dnc;
int visa[300010];
bool visp[3100][3100];
int main()
{
    int t;
    scanf("%d", &t);
    int Case = 1;
    while (t--)
    {
        dnc.Init();
        int na, nb;
        memset(visa, 0, sizeof(visa));
        memset(visp, 0, sizeof(visp));
        string tmp;
        int price, chnl;
        int sum = 0;

        scanf("%d", &na);
        getline(cin, tmp);
        for (int i = 1; i <= na; i++)
        {
            getline(cin, tmp);
            stringstream ssin(tmp);
            ssin >> price;
            sum += price;
            while (ssin >> chnl)
            {
                visa[chnl] = i;
            }
            dnc.addedge(0, i, price);
        }
        scanf("%d", &nb);
        getline(cin, tmp);
        for (int i = na + 1; i <= na + nb; i++)
        {
            getline(cin, tmp);
            stringstream ssin(tmp);
            ssin >> price;
            sum += price;
            while (ssin >> chnl)
            {
                if (visa[chnl] && !visp[visa[chnl]][i - na])
                {
                    dnc.addedge(visa[chnl], i, INF);
                    visp[visa[chnl]][i - na] = true;
                }
            }
            dnc.addedge(i, na + nb + 1, price);
        }
        dnc.set(na + nb + 2, 0, na + nb + 1);
        int ans = dnc.cal_maxflow();//所有矛盾的bid组数中代价的最小值
        printf("Case %d:
", Case++);
        printf("%d
", sum - ans);
        if (t) printf("
");
    }
    return 0;
}