CF 510E Fox And Dinner（最大流）

最新推荐文章于 2021-02-05 20:30:29 发布
最新推荐文章于 2021-02-05 20:30:29 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： 网络流专题 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011699990/article/details/45932335
版权

CF 510E Fox And Dinner

n个狐狸围桌吃饭 每个狐狸身上自带一个值fi 现在要使得相邻的两个狐狸Fi Fi+1的和为质数（F1与Fn相邻）

问可以把这些狐狸安排到几个桌子 如果可以给出每个桌子上狐狸安排的顺序


因为每个每个Fi的值都是大于2的 所以两个值相加要为质数  这个质数肯定是个奇数  所以要满足奇数+偶数

所以把初始的n个值分为两部分 一个部分为奇数部分 一个为偶数部分

且每个奇数与两个偶数相邻 每个偶数与两个奇数相邻

虚拟一个源点 汇点 源点与偶数之间建边 权值为2  奇数与汇点之间建边 权值为2

满足相加为质数的偶数与奇数之间建边 权值为1  跑最大流 看答案是否为n

然后需要去存储答案  如果奇数与偶数之间有流  则说明这条边是满足情况的 从一个点出发找出一条路径

即是一个桌子的情况

注意这道题建的是有向边

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <string.h>
#include <string>
#include <vector>
#include <queue>

#define MEM(a,x) memset(a,x,sizeof a)
#define eps 1e-8
#define MOD 10009
#define MAXN 410
#define MAXM 100010
#define INF 99999999
#define ll __int64
#define bug cout<<"here"<<endl
#define fread freopen("ceshi.txt","r",stdin)
#define fwrite freopen("out.txt","w",stdout)

using namespace std;

int Read()
{
    char c = getchar();
    while (c < '0' || c > '9') c = getchar();
    int x = 0;
    while (c >= '0' && c <= '9') {
        x = x * 10 + c - '0';
        c = getchar();
    }
    return x;
}

void Print(int a)
{
     if(a>9)
         Print(a/10);
     putchar(a%10+'0');
}

struct Edge
{
    int from,to,cap,flow;
    bool operator <(const Edge e) const
    {
        if(e.from!=from)  return from<e.from;
        else return to<e.to;
    }
    Edge() {}
    Edge(int from,int to,int cap,int flow):from(from),to(to),cap(cap),flow(flow) {}
};

struct Dinic
{
    vector<Edge> edges;
    vector<int> G[MAXN];
    bool vis[MAXN];//BFS使用
    int d[MAXN];   //从起点到i的距离
    int cur[MAXN]; //当前弧下标
    int n,m,s,t,maxflow;   //节点数 边数（包括反向弧） 源点编号和弧点编号

    void init(int n)
    {
        this->n=n;
        for(int i=0;i<=n;i++)
            G[i].clear();
        edges.clear();
    }

    void addedge(int from,int to,int cap)
    {
        edges.push_back(Edge(from,to,cap,0));
        edges.push_back(Edge(to,from,0,0));//当是无向图时，反向边容量也是cap,有向边时，反向边容量是0
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool bfs()
    {
        MEM(vis,0);
        MEM(d,-1);
        queue<int> q;
        q.push(s);
        d[s]=maxflow=0;
        vis[s]=1;
        while(!q.empty())
        {
            int u=q.front(); q.pop();
            int sz=G[u].size();
            for(int i=0;i<sz;i++)
            {
                Edge e=edges[G[u][i]];
                if(!vis[e.to]&&e.cap>e.flow)
                {
                    d[e.to]=d[u]+1;
                    vis[e.to]=1;
                    q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int dfs(int u,int a)
    {
        if(u==t||a==0)  return a;
        int sz=G[u].size();
        int flow=0,f;
        for(int &i=cur[u];i<sz;i++)
        {
            Edge &e=edges[G[u][i]];
            if(d[u]+1==d[e.to]&&(f=dfs(e.to,min(a,e.cap-e.flow)))>0)
            {
                e.flow+=f;
                edges[G[u][i]^1].flow-=f;
                flow+=f;
                a-=f;
                if(a==0)  break;
            }
        }
        return flow;
    }

    int Maxflow(int s,int t)
    {
        this->s=s; this->t=t;
        int flow=0;
        while(bfs())
        {
            MEM(cur,0);
            flow+=dfs(s,INF);
        }
        return flow;
    }

}Dic;

bool notprime[50010];//值为0表示素数  为1表示非素数
void isprime()
{
    MEM(notprime,0);
    notprime[0]=notprime[1]=1;
    for(int i=2;i<50000;i++)
    {
        if(!notprime[i])
        {
            if(i>50000/i) continue;
            for(int j=i*i;j<50000;j+=i)
                notprime[j]=1;
        }
    }
}

bool isPrime(int n)
{
    for(int i=2;i*i<=n;i++)
        if(n%i==0) return 0;
    return 1;
}

int vis[MAXN];
int a[MAXN];
vector<int> g[MAXN];

int main()
{
//    fread;
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
        scanf("%d",&a[i]);
    Dic.init(n+1);
    int s=n,t=n+1;
    for(int i=0;i<n;i++)
    {
        if(a[i]%2==0)
            Dic.addedge(s,i,2);
        else Dic.addedge(i,t,2);
    }
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            if(a[i]%2==0&&a[j]%2!=0&&isPrime(a[i]+a[j]))
                Dic.addedge(i,j,1);
        }
    }
    int res=Dic.Maxflow(s,t);
    if(res!=n)
    {
        puts("Impossible");
        return 0;
    }
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<Dic.G[i].size();j++)
        {
            int index=Dic.G[i][j];
            if(Dic.edges[index].flow>0&&Dic.edges[index].to<n)
            {
                g[i].push_back(Dic.edges[index].to);
                g[Dic.edges[index].to].push_back(i);
            }
        }
    }
    vector< vector<int> > path;
    for(int i=0;i<n;i++)
    {
        if(vis[i])
            continue;
        vector<int> current;
        int j=i;
        while(1)
        {
            current.push_back(j);
            vis[j]=1;
            int nj=-1;
            for(int k=0;k<g[j].size();k++)
            {
                if(!vis[g[j][k]])
                {
                    nj=g[j][k];
                    break;
                }
            }
            if(nj==-1)
            {
                break;
            }
            j=nj;
        }
        path.push_back(current);
    }
    printf("%d\n",path.size());
    for(int i=0;i<path.size();i++)
    {
        printf("%d",path[i].size());
        for(int j=0;j<path[i].size();j++)
            printf(" %d",path[i][j]+1);
        printf("\n");
    }
    return 0;
}


//int main()
//{
    fread;
//    isprime();
//    int n;
//    scanf("%d",&n);
    while(scanf("%d",&n)!=EOF)
    {
//        for(int i=1;i<=n;i++)
//            scanf("%d",&a[i]);
        int n1=0,n2=0;
        for(int i=1;i<=n;i++)
        {
            if(a[i]&1)
            {
                a1[++n1]=a[i];
                num1[n1]=i;
            }
            else
            {
                a2[++n2]=a[i];
                num2[n2]=i;
            }
        }
        if(n1!=n2)
        {
            puts("Impossible");
            continue;
        }
        int s=0,t=n+1;
        Dic.init(t);
        for(int i=1;i<=n1;i++)
            Dic.addedge(s,i,2);
        for(int i=1;i<=n2;i++)
            Dic.addedge(i+n1,t,2);
//        cout<<"n "<<n<<"  "<<n1+n2<<endl;
        for(int i=1;i<=n1;i++)
            for(int j=1;j<=n2;j++)
            {
                if(!notprime[a1[i]+a2[j]])
                    Dic.addedge(i,j+n1,1);
            }
        int mxflow=Dic.Maxflow(s,t);
        if(mxflow!=n)
        {
            puts("Impossible");
            continue;
        }
//        int s=0,t=n+1;
//        Dic.init(t);
//        for(int i=1;i<=n;i++)
//        {
//            if(a[i]%2==0)
//                Dic.addedge(s,i,2);
//            else Dic.addedge(i,t,2);
//        }
//        for(int i=1;i<=n;i++)
//            for(int j=1;j<=n;j++)
//            {
//                if(a[i]%2==0&&a[j]%2!=0&&!notprime[a[i]+a[j]])
//                    Dic.addedge(i,j,1);
//            }
//        int res=Dic.Maxflow(s,t);
//        if(res!=n)
//        {
//            puts("Impossible");
//            return 0;
//        }
        for(int i=0;i<=t;i++)
            g[i].clear();
//        for(int i=1;i<=n;i++)
//        {
//            for(int j=0;j<Dic.G[i].size();j++)
//            {
//                int index=Dic.G[i][j];
//                if(Dic.edges[index].flow>0&&Dic.edges[index].to<=n)
//                {
//                    g[i].push_back(Dic.edges[index].to);
//                    g[Dic.edges[index].to].push_back(i);
//                }
//            }
//        }
//        vector< vector<int> > path;
//        MEM(vis,0);
//        for(int i=1;i<=n;i++)
//        {
//            if(vis[i]) continue;
//            vector<int> current;
//            int j=i;
//            while(1)
//            {
//                current.push_back(j);
//                vis[j]=1;
//                int nj=-1;
//                for(int k=0;k<g[j].size();k++)
//                {
//                    if(!vis[g[j][k]])
//                    {
//                        nj=g[j][k];
//                        break;
//                    }
//                }
//                if(nj==-1)
//                {
//                    break;
//                }
//                j=nj;
//            }
//            path.push_back(current);
//        }
//        printf("%d\n",path.size());
//        for(int i=0;i<path.size();i++)
//        {
//            printf("%d",path[i].size());
//            for(int j=0;j<path[i].size();j++)
//                printf(" %d",path[i][j]);
//            puts("");
//        }
        int tot=0;
        for(int i=1;i<=n1;i++)
        {
            int sz=Dic.G[i].size();
            for(int j=0;j<sz;j++)
            {
                int x=Dic.G[i][j];
                if(Dic.edges[x].flow>0)
                {
                    ans[++tot][1]=num1[i];
                    ans[tot][2]=num2[Dic.edges[x].to-n1];
                }
            }
        }
        int m=0;
        MEM(vis,0);
        MEM(st,0);
        for(int i=1;i<=tot;i++)
        {
            if(!vis[i])
            {
                vis[i]=1;
                st[++m][1]=ans[i][1];
                st[m][2]=ans[i][2];
                int st_size=2;
                while(st[m][1]!=st[m][st_size])
                {
                    for(int i=1;i<=tot;i++)
                    {
                        if(!vis[i])
                        {
                            if(ans[i][1]==st[m][st_size])
                            {
                                st[m][++st_size]=ans[i][2];
                                vis[i]=1;
                                break;
                            }
                            if(ans[i][2]==st[m][st_size])
                            {
                                st[m][++st_size]=ans[i][1];
                                vis[i]=1;
                                break;
                            }
                        }
                    }
                }
                st[m][0]=st_size-1;
            }
        }
        printf("%d\n",m);
        for(int i=1;i<=m;i++)
        {
//            cout<<"i  "<<i<<endl;
            printf("%d",st[i][0]);
            for(int j=1;j<=st[i][0];j++)
                printf(" %d",st[i][j]);
            puts("");
        }
    }
//
//    return 0;
//}




理想主义文艺青年
关注
专栏目录
最大流与最小割Maximum Flow and Minimum Cut
qq_41209114的博客
11-26 5019
一、网络流问题 给出一个有向图G=(u,v)，两个不同的节点s与t，其中边上的c为该边上能够通过的最大容量（Capacity）；求满足条件的从S到T的最大流(MaxFlow)； 用c(e)和f(e)分别表示每条边上的容量（Capacity）与流量（Flow）； 1.1s-t cut s-t cut :是顶点集合V的一个划分，将其分为两个集合，其中s ∈A 且t ∈ B； cut (A, B)的容量capacity： Minimum Cut Problem：即找到一个割集，使得cap...
浅谈求解最大流的方法
热门推荐
一青年的专栏
04-10 1万+
还是前几天参加的2014阿里巴巴春季校招（测试开发岗）笔试. 有道选择题给出了每条有向公路最大流量，请问从源点到汇点的最大流量是...
cf 510E Fox And Dinner 网络流
KIDGIN7439的专栏
02-16 525
题意：每个狐狸都有一个编号，问是否可以将狐狸分成几个桌子，使得相邻的狐狸的编号和为素数，每个桌子至少有三个。 只有相邻两个狐狸一奇一偶才有可能为素数，且每一个狐狸度数为2，所以建立一个二分图，一边为偶，一边为奇，源点到偶度数容量为2，奇数到汇点容量为2，一个偶数加一个奇数为素数，则连接这两点，跑最大流，若流量为n则可以，否则不可能。 #include #include #include
CF510E： Fox And Dinner
NEONwuwu的博客
10-31 289
E. Fox And Dinner time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output Fox Ciel is participating in a party in Prime Kingdom. There are n foxes...
[Codeforces 510E] Fox And Dinner （网络流+分组建图）
MisDeer's blog
01-25 346
Codeforces - 510E 有 N只狐妖，其中年龄加起来为质数的可以坐在一次 求一种方案，使所有人都坐成若干个环 注意到每个人的年龄都大于等于2 这意味着所有的质数都是奇数 相邻两个一个是奇数，一个是偶数 所以整张图是一个二分图然后跑网络流 源点对奇数点连容量为 2的边 偶数点对汇点连容量为 2的边 中间奇数点对偶数点连容量为 1的边 表示每个点至多有两个邻居 最后
CF510E： Fox And Dinner（最大流）
junior19的博客
03-07 415
E. Fox And Dinnertime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputFox Ciel is participating in a party in Prime Kingdom. There are n foxes there (i...
Codeforces - Fox And Dinner
青烟绕指柔的博客
12-27 290
Fox Ciel is participating in a party in Prime Kingdom. There are n foxes there (include Fox Ciel). The i-th fox is ai years old. They will have dinner around some round tables. You want to distribute ...
算法导论 26章 最大流(一)
V然成风
03-22 4818
最大流问题 为了求一点到另一点的最短距离，我们可以把公路地图模型化为有向图。同理，我们可以将公路模型化为一个“流网络”（flow network），并运用它来解决物流相关的问题。其中最大流问题是其中一种，即：在不违背每条路（即有向图的边）的容量的情况下，可以把物质从源点送到汇点的最大速率是多少。最大流定义和性质 流网络是一个有向图G=（V,E），其中每条边(u
Codeforces Round #290 (Div. 1)B. Fox And Jumping
Alex
02-03 2222
B. Fox And Jumping time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output Fox Ciel is playing a game. In this game there is
算法导论随笔(十一)：最大流(Max-Flow)与Ford-Fulkerson算法(附Python实现源码)
天降风云的博客
09-01 6194
前面的几篇文章中我们讨论了一些图的算法。其中大部分都是关于无向图的算法。这篇文章里我来说说有向图的算法。先说一说有向图的一个应用，也就是流网络(Flow Network)。 1. 流网络 先来看流网络的定义。对于流网络，《算法导论》第26章是这样定义的： 流网络 G = (V, E)是一个有向图，图中每一条边(u, v) ∈ E有一个非负的容量值c(u, v) >=0。而且，如果边集合E包含一条边(u, v)，则图中不存在反方向的边(v, u)。如果(u, v) ∉ E，则为方便起见，定义c(u,
CF512C Fox And Dinner（数学+二分图+最大流）
Icefox的博客
12-23 397
%%%Elijahqi，秒题的神犇。 首先我们发现，如果两个数的和是质数，则一定是一奇一偶，所以环一定是偶环，我们可以根据奇偶性黑白染色，变成一张二分图。题目保证环的大小一定大于等于3，所以每个点的度一定是2。那么我们就可以直接建图跑最大流来判断是否可行了。S向白点建边，容量为2，黑点向T建边，容量为2，白点向能相邻的黑点建边，容量为1。看是否满流即可。
codeforces 510E Fox And Dinner 奇偶建图+最大流
AC_kereo的专栏
02-04 1029
题意：n个fox，年龄为a[i]。             现在要将n个fox分配入座，保证与相邻数的和为质数。一桌至少三个fox。             输出要分几桌，每桌几个fox，按顺序输出每桌坐的fox的id 思路：我们按奇偶将n个fox分成2类，如果左边的a[i]+右边的a[j]和为质数，那么建i->j建容量为1的边，超级起点0连a[i]为奇数的i， 从0->i建容量为2的
CF 510E(Fox And Dinner-把质数拆成奇数和偶数)
nike0good |Oier&ACMer | 熟能生巧
02-21 1120
E. Fox And Dinner time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output Fox Ciel is participating in a party in P
Codeforces Round #290 (Div. 1) C. Fox And Dinner 奇偶建图跑最大流
狙击美佐的博客
02-05 160
Codeforces Round #290 Div. 1 C. Fox And Dinner 奇偶建图跑最大流题意思路Code（30MS） 传送门：https://codeforces.com/contest/512/problem/C 题意 有n个数，问能不能把n个数分成k桌，且要求如下有n个数，问能不能把n个数分成k桌，且要求如下有n个数，问能不能把n个数分成k桌，且要求如下 每桌至少3个数以上每桌至少3个数以上每桌至少3个数以上 一桌上相邻的数相加为素数一桌上相邻的数相加为素数一桌上相邻的数相加为素
poj 2175 Evacuation Plan（最小费用流 （消圈算法））
youngkl博客
03-17 2021
Evacuation Plan Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 3689   Accepted: 980   Special Judge Description The City has a number of municipal buildin
poj 2112 Optimal Milking（floyd+二分+最大流）
youngkl博客
12-24 1801
Language: Default Optimal Milking Time Limit: 2000MS   Memory Limit: 30000K Total Submissions: 12782   Accepted: 4612 Case Time Limit: 1000MS Description FJ has
poj 2391 Ombrophobic Bovines（最大流（拆点）+floyd+二分）
youngkl博客
02-21 1250
Ombrophobic Bovines Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 15705   Accepted: 3425 Description FJ's cows really hate getting wet so much that the m
poj 1459 zoj 1734 Power Network（最大流）
youngkl博客
12-16 1235
电网 中一些节点  可能会消耗电能  提供电能   节点之间有电线传输电能  传输的电能有上限值 节点中没有 源点和汇点 类型的节点  所以需要我们添加源点汇点  n个节点 从0开始 设源点为n+1  汇点为n+2 源点到每个电站之间添加一条边 权值为该电站能够提供的电能 每个消费者与汇点之间添加一条边 权值为该消费者消费的电能 根据所给的 电线中的起点和重点 添加边 权值为该电线能够
CF Sets and Union
最新发布
09-26
引用中提到的CF Sets和Union是一种用于在查询结果中创建不同组合的分组集的方法。CF Sets是指grouping sets、rollup和cube的组合使用，可以在查询结果中创建多个组合。Union是用于将多个查询结果组合在一起的操作。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值