HDU 4975 最大流+判断环

点击打开链接

题意:给定的分别是每行值的和,每列值的和,每个元素的值在0~9之间,问有多少种情况符合条件,多种,一种和不可能分别输出三种情况

思路:刚读完题根本没有思路,看了网上的才知道用网络流,那样的话就好办了,建个源点,与每行建一条流量为行和的边,每一列与汇点建一条流量为列和的边,每行与每列建一条流量为9的边,跑最大流后判断是否满流就行了,但是要怎么判断有没有多组解呢,当残余网络中有环时,我们可以调整这个环来符合条件,将一条边加1,则另一条边可以减去1,所以判断残余网络中有没有大于2的环,并不会......,看大多数题解都是dfs回溯时删边或者删点,并不会,然后我的做法是将可行的边先预处理出来,然后非常暴力的dfs,一不小心400ms过了.......

#include <queue>
#include <vector>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const int maxn=1010;
struct edge{
    int to,cap,rev;
    edge(int a,int b,int c){to=a;cap=b;rev=c;}
};
vector<edge>G[maxn];
vector<int>G1[maxn];
int level[maxn],iter[maxn],vis[maxn],n,m;
void addedge(int from,int to,int cap){
    G[from].push_back(edge(to,cap,G[to].size()));
    G[to].push_back(edge(from,0,G[from].size()-1));
}
void add_edge(int from,int to){
    G1[from].push_back(to);
}
void bfs(int s){
    memset(level,-1,sizeof(level));
    queue<int>que;level[s]=0;
    que.push(s);
    while(!que.empty()){
        int v=que.front();que.pop();
        for(unsigned int i=0;i<G[v].size();i++){
            edge &e=G[v][i];
            if(e.cap>0&&level[e.to]<0){
                level[e.to]=level[v]+1;
                que.push(e.to);
            }
        }
    }
}
int dfs(int v,int t,int f){
    if(v==t) return f;
    for(int &i=iter[v];i<G[v].size();i++){
        edge &e=G[v][i];
        if(e.cap>0&&level[v]<level[e.to]){
            int d=dfs(e.to,t,min(f,e.cap));
            if(d>0){
                e.cap-=d;
                G[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}
int max_flow(int s,int t){
    int flow=0;
    while(1){
        bfs(s);
        if(level[t]<0) return flow;
        memset(iter,0,sizeof(iter));
        int f;
        while((f=dfs(s,t,inf))>0) flow+=f;
    }
}
bool Judge_dfs(int x,int val){
    vis[x]=1;
    for(unsigned int i=0;i<G1[x].size();i++){
        int t=G1[x][i];
        if(t==val) continue;
        if(vis[t]) return 1;
        if(Judge_dfs(t,x)) return 1;
    }
    vis[x]=0;
    return 0;
}
bool judge(){
    memset(vis,0,sizeof(vis));
    for(int i=0;i<=n+m+1;i++){
        for(unsigned int j=0;j<G[i].size();j++){
            edge &e=G[i][j];
            if(e.cap>0) add_edge(i,e.to);
        }
    }
    for(int i=0;i<=n;i++){
        if(Judge_dfs(i,-1)) return 1;
    }
    return 0;
}
int main(){
    int T,a,b,t=1;
    scanf("%d",&T);
    while(T--){
        for(int i=0;i<maxn;i++){
            G[i].clear();
            G1[i].clear();
        }
        scanf("%d%d",&n,&m);
        int sum=0,sum1=0,sum2=0;
        for(int i=1;i<=n;i++){
            scanf("%d",&a);sum+=a;sum1+=a;
            addedge(0,i,a);
        }
        for(int j=1;j<=m;j++){
            scanf("%d",&b);sum2+=b;
            addedge(j+n,n+m+1,b);
        }
        if(sum1!=sum2){
            printf("Case #%d: So naive!\n",t++);
            continue;
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++)
                addedge(i,j+n,9);
        }
        int ans=max_flow(0,n+m+1);
        if(ans!=sum) printf("Case #%d: So naive!\n",t++);
        else{
            if(judge()) printf("Case #%d: So young!\n",t++);
            else printf("Case #%d: So simple!\n",t++);
        }
    }
    return 0;
}
时间: 2024-10-01 07:47:31

HDU 4975 最大流+判断环的相关文章

hdu 4975最大流与4888类似但是有很吊的优化最大流

//来自潘神的优化 #include<stdio.h> #include<string.h> #include<queue> using namespace std; #define inf 0x3fffffff #define N 1100 struct node { int u,v,w,next; }bian[N*N*4]; int head[N],yong,dis[N],work[N]; void init(){ yong=0; memset(head,-1,si

hdu 4975 最大流及其唯一性判定(有向图环判断算法升级)

就当时最大流再次复习吧..动手敲一下...经典解法不想说了..这题主要是坑时间,10个提交7个tle. 环的判断,曾经用简单dfs方法,这次的就tle了!别人说要用很屌的dinic,我感觉自己dinic不可能超时,坚信是判断环慢了,于是学习了新断环的方法:删除点/边!从某点进去,若该点的所有边都遍历过还是无功而返,那么该店以后不用再进入了(这么简单的道感觉自己应该要想到啊!愚蠢啊!)开始时用只删除边,还是tle!nb!于是自己删点又删边,一下到156ms,前5了! #include<cstdio

hdu 4975 最大流解决行列和求矩阵问题,用到矩阵dp优化

//刚开始乱搞. //网络流求解,如果最大流=所有元素的和则有解:利用残留网络判断是否唯一, //方法有两种,第一种是深搜看看是否存在正边权的环,见上一篇4888 //至少3个点构成的环,第二种是用矩阵dp,只需要满足某行的i列元素<9,j列元素>0,而另一行的i列元素>0,j列元素<9, //可以满足互补就证明不唯一,这个画图不难看出 #include<stdio.h> #include<string.h> #include<queue> us

HDU 4975 (杭电多校 #10 1005题)A simple Gaussian elimination problem.(网络流之最大流)

题目地址:HDU 4975 对这题简直无语...本来以为这题要用什么更先进的方法,结果还是老方法,这么卡时间真的好吗....比赛的时候用了判环的方法,一直TLE..后来换了矩阵DP的方式,加了加剪枝就过了..无语了.. 代码如下: #include <cstdio> #include <cstring> #include <algorithm> #include <iostream> #include <cstdio> #include <

HDU 4888 Redraw Beautiful Drawings(最大流+判最大流网络是否唯一)

Problem Description Alice and Bob are playing together. Alice is crazy about art and she has visited many museums around the world. She has a good memory and she can remember all drawings she has seen. Today Alice designs a game using these drawings

hdu 4975 A simple Gaussian elimination problem.(网络流,判断矩阵是否存在)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4975 Problem Description Dragon is studying math. One day, he drew a table with several rows and columns, randomly wrote numbers on each elements of the table. Then he counted the sum of each row and col

HDU 4975 A simple Gaussian elimination problem. 网络流+矩阵上的dp

随机输出保平安啊 和hdu4888一个意思,先跑个网络流然后dp判可行. ==n^3的dp过不了,所以把n改成200. ==因为出题人没有把多解的情况放在200*200以外的矩阵. #include <cstdio> #include <cstring> #include <vector> #include <queue> #include <algorithm> using namespace std; const int MAX_N = 12

2014多校联合十(HDU 4972 HDU 4973 HDU 4974 HDU 4975)

HDU 4972 A simple dynamic programming problem 题意:篮球比赛有1.2.3分球  现给出两队的分差序列(5:3 分差2  3:5分差也是2)  问有多少种可能的比分 思路: 比较简单的想法题  可以类一张表"从分差x到分差y一共有几种情况"  很容易发现只有1->2和2->1的时候会多一种情况  其他均是一种  所以只需要统计这种特殊分差即可  注意一下最后结果要不要乘2  如果最后分差是0就不用因为x:x只有一种  但是最后分差

hdu 4888 最大流给出行列和求矩阵

第一步,考虑如何求是否有解.使用网络流求解,每一行和每一列分别对应一个点,加上源点和汇点一共有N+M+2个点.有三类边: 1. 源点 -> 每一行对应的点,流量限制为该行的和 2. 每一行对应的点 -> 每一列对应的点,流量限制为 K 3. 每一列对应的点 -> 汇点,流量限制为该列的和 对上图做最大流,若源点出发的边和到达汇点的边全都满流,则有解,否则无解.若要求构造方案,则 (i,j) 对应的整数就是行 i–> 列 j 的流量. 第二步,考虑解是否唯一.显然,解唯一的充分必要条